From 46c082c402a841a378e60c6d636df1e03dd07f25 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Piwo=C5=84ski?= Date: Mon, 20 Mar 2023 15:48:45 +0100 Subject: [PATCH] Erc20 storage fixes (#979) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Get rid of hashbuiltin * Fix WARP_USED_STORAGE * Cleanup * Fix WARP_NAMEGEN * Fix storage consts * Fix LegacyMap issues * Fix uint256 serialization and construction * Add missing condition * Fix structs serialization * Change `get_caller_address`path * Transform `get_caller_address` output to felt * Remove unused import * Warplib import (#985) * create u256 from 2 felts (#975) * proposed sol: warplib import * Add warplib::integer to corelib * Add warplib::integer to x64 * Add integer functions to warplib.cairo --------- Co-authored-by: Alejandro Labourdette <66191544+AlejandroLabourdette@users.noreply.github.com> Co-authored-by: Piotr Piwoński Co-authored-by: Piotr Piwoński * Revert using `::` in generated functions not ported to cairo 1 yet * Revert `WARP_USED_STORAGE::` in cairo 0.x scripts * Remove unused import * follow import convention * Fix warplib errors * Add missing math imports to arm warplib.cairo * Rename UINT256 to GET_U128 * Create ADDRESS_INTO_FELT import directly * Revert "Create ADDRESS_INTO_FELT import directly" This reverts commit f388dc688389cb97cccfb56e3deb7259079db3ea. * Replace `get_u128_try_from_felt_result` with corelib implementation * Add newlines --------- Co-authored-by: Piotr Piwoński Co-authored-by: Rohit Ranjan Co-authored-by: Alejandro Labourdette <66191544+AlejandroLabourdette@users.noreply.github.com> --- cairo1/darwin_arm64/corelib/src/lib.cairo | 10 + cairo1/darwin_arm64/corelib/src/warplib.cairo | 10 + .../corelib/src/warplib/integer.cairo | 15 + .../corelib/src/warplib/maths.cairo | 10 + .../corelib/src/warplib/maths/add.cairo | 192 + .../src/warplib/maths/add_signed.cairo | 420 ++ .../src/warplib/maths/add_signed_unsafe.cairo | 165 + .../src/warplib/maths/add_unsafe.cairo | 131 + .../corelib/src/warplib/maths/addmod.cairo | 39 + .../corelib/src/warplib/maths/and_.cairo | 4 + .../src/warplib/maths/bitwise_and.cairo | 15 + .../src/warplib/maths/bitwise_not.cairo | 133 + .../src/warplib/maths/bitwise_or.cairo | 15 + .../src/warplib/maths/bytes_access.cairo | 98 + .../src/warplib/maths/bytes_conversions.cairo | 35 + .../corelib/src/warplib/maths/div.cairo | 28 + .../src/warplib/maths/div_signed.cairo | 549 ++ .../src/warplib/maths/div_signed_unsafe.cairo | 549 ++ .../src/warplib/maths/div_unsafe.cairo | 28 + .../corelib/src/warplib/maths/eq.cairo | 14 + .../corelib/src/warplib/maths/exp.cairo | 1502 ++++ .../src/warplib/maths/exp_signed.cairo | 1758 +++++ .../src/warplib/maths/exp_signed_unsafe.cairo | 1758 +++++ .../src/warplib/maths/exp_unsafe.cairo | 1502 ++++ .../maths/external_input_check_address.cairo | 7 + .../maths/external_input_check_bool.cairo | 9 + .../maths/external_input_check_ints.cairo | 160 + .../corelib/src/warplib/maths/ge.cairo | 8 + .../corelib/src/warplib/maths/ge_signed.cairo | 165 + .../corelib/src/warplib/maths/gt.cairo | 15 + .../corelib/src/warplib/maths/gt_signed.cairo | 165 + .../src/warplib/maths/int_conversions.cairo | 6087 +++++++++++++++++ .../corelib/src/warplib/maths/le.cairo | 12 + .../corelib/src/warplib/maths/le_signed.cairo | 909 +++ .../corelib/src/warplib/maths/lt.cairo | 15 + .../corelib/src/warplib/maths/lt_signed.cairo | 258 + .../corelib/src/warplib/maths/mod.cairo | 28 + .../src/warplib/maths/mod_signed.cairo | 419 ++ .../corelib/src/warplib/maths/mul.cairo | 246 + .../src/warplib/maths/mul_signed.cairo | 1214 ++++ .../src/warplib/maths/mul_signed_unsafe.cairo | 454 ++ .../src/warplib/maths/mul_unsafe.cairo | 198 + .../corelib/src/warplib/maths/mulmod.cairo | 38 + .../corelib/src/warplib/maths/negate.cairo | 164 + .../corelib/src/warplib/maths/neq.cairo | 14 + .../corelib/src/warplib/maths/or.cairo | 7 + .../corelib/src/warplib/maths/pow2.cairo | 267 + .../corelib/src/warplib/maths/shl.cairo | 730 ++ .../corelib/src/warplib/maths/shr.cairo | 808 +++ .../src/warplib/maths/shr_signed.cairo | 1004 +++ .../corelib/src/warplib/maths/sub.cairo | 30 + .../src/warplib/maths/sub_signed.cairo | 648 ++ .../src/warplib/maths/sub_signed_unsafe.cairo | 505 ++ .../src/warplib/maths/sub_unsafe.cairo | 100 + .../corelib/src/warplib/maths/utils.cairo | 72 + .../corelib/src/warplib/maths/xor.cairo | 15 + cairo1/linux_x64/corelib/src/lib.cairo | 10 + cairo1/linux_x64/corelib/src/warplib.cairo | 10 + .../corelib/src/warplib/integer.cairo | 15 + .../linux_x64/corelib/src/warplib/maths.cairo | 10 + .../corelib/src/warplib/maths/add.cairo | 192 + .../src/warplib/maths/add_signed.cairo | 420 ++ .../src/warplib/maths/add_signed_unsafe.cairo | 165 + .../src/warplib/maths/add_unsafe.cairo | 131 + .../corelib/src/warplib/maths/addmod.cairo | 39 + .../corelib/src/warplib/maths/and_.cairo | 4 + .../src/warplib/maths/bitwise_and.cairo | 15 + .../src/warplib/maths/bitwise_not.cairo | 133 + .../src/warplib/maths/bitwise_or.cairo | 15 + .../src/warplib/maths/bytes_access.cairo | 98 + .../src/warplib/maths/bytes_conversions.cairo | 35 + .../corelib/src/warplib/maths/div.cairo | 28 + .../src/warplib/maths/div_signed.cairo | 549 ++ .../src/warplib/maths/div_signed_unsafe.cairo | 549 ++ .../src/warplib/maths/div_unsafe.cairo | 28 + .../corelib/src/warplib/maths/eq.cairo | 14 + .../corelib/src/warplib/maths/exp.cairo | 1502 ++++ .../src/warplib/maths/exp_signed.cairo | 1758 +++++ .../src/warplib/maths/exp_signed_unsafe.cairo | 1758 +++++ .../src/warplib/maths/exp_unsafe.cairo | 1502 ++++ .../maths/external_input_check_address.cairo | 7 + .../maths/external_input_check_bool.cairo | 9 + .../maths/external_input_check_ints.cairo | 160 + .../corelib/src/warplib/maths/ge.cairo | 8 + .../corelib/src/warplib/maths/ge_signed.cairo | 165 + .../corelib/src/warplib/maths/gt.cairo | 15 + .../corelib/src/warplib/maths/gt_signed.cairo | 165 + .../src/warplib/maths/int_conversions.cairo | 6087 +++++++++++++++++ .../corelib/src/warplib/maths/le.cairo | 12 + .../corelib/src/warplib/maths/le_signed.cairo | 909 +++ .../corelib/src/warplib/maths/lt.cairo | 15 + .../corelib/src/warplib/maths/lt_signed.cairo | 258 + .../corelib/src/warplib/maths/mod.cairo | 28 + .../src/warplib/maths/mod_signed.cairo | 419 ++ .../corelib/src/warplib/maths/mul.cairo | 246 + .../src/warplib/maths/mul_signed.cairo | 1214 ++++ .../src/warplib/maths/mul_signed_unsafe.cairo | 454 ++ .../src/warplib/maths/mul_unsafe.cairo | 198 + .../corelib/src/warplib/maths/mulmod.cairo | 38 + .../corelib/src/warplib/maths/negate.cairo | 164 + .../corelib/src/warplib/maths/neq.cairo | 14 + .../corelib/src/warplib/maths/or.cairo | 7 + .../corelib/src/warplib/maths/pow2.cairo | 267 + .../corelib/src/warplib/maths/shl.cairo | 730 ++ .../corelib/src/warplib/maths/shr.cairo | 808 +++ .../src/warplib/maths/shr_signed.cairo | 1004 +++ .../corelib/src/warplib/maths/sub.cairo | 30 + .../src/warplib/maths/sub_signed.cairo | 648 ++ .../src/warplib/maths/sub_signed_unsafe.cairo | 505 ++ .../src/warplib/maths/sub_unsafe.cairo | 100 + .../corelib/src/warplib/maths/utils.cairo | 72 + .../corelib/src/warplib/maths/xor.cairo | 15 + src/cairoUtilFuncGen/abi/abiDecode.ts | 6 +- src/cairoUtilFuncGen/abi/abiEncode.ts | 4 +- src/cairoUtilFuncGen/abi/abiEncodePacked.ts | 4 +- .../abi/abiEncodeWithSelector.ts | 4 +- .../abi/abiEncodeWithSignature.ts | 4 +- src/cairoUtilFuncGen/abi/indexEncode.ts | 4 +- .../calldata/calldataToMemory.ts | 8 +- .../calldata/implicitArrayConversion.ts | 4 +- src/cairoUtilFuncGen/enumInputCheck.ts | 4 +- src/cairoUtilFuncGen/event.ts | 6 +- src/cairoUtilFuncGen/memory/arrayConcat.ts | 6 +- src/cairoUtilFuncGen/memory/arrayLiteral.ts | 4 +- .../memory/implicitConversion.ts | 8 +- src/cairoUtilFuncGen/memory/memoryStruct.ts | 4 +- .../memory/memoryToCalldata.ts | 6 +- .../memory/memoryToStorage.ts | 4 +- src/cairoUtilFuncGen/serialisation.ts | 24 +- src/cairoUtilFuncGen/storage/copyToStorage.ts | 10 +- .../storage/dynArrayIndexAccess.ts | 4 +- src/cairoUtilFuncGen/storage/dynArrayPop.ts | 4 +- .../storage/dynArrayPushWithArg.ts | 4 +- .../storage/dynArrayPushWithoutArg.ts | 4 +- .../storage/mappingIndexAccess.ts | 4 +- src/cairoUtilFuncGen/storage/storageDelete.ts | 6 +- .../storage/storageToCalldata.ts | 4 +- .../storage/storageToMemory.ts | 6 +- src/cairoUtilFuncGen/storage/storageWrite.ts | 12 +- .../writers/cairoContractWriter.ts | 4 +- .../writers/cairoFunctionDefinitionWriter.ts | 4 +- src/passes/annotateImplicits.ts | 11 +- src/passes/builtinHandler/msgSender.ts | 29 +- src/passes/cairoUtilImporter.ts | 14 +- src/utils/cairoTypeSystem.ts | 2 +- src/utils/implicits.ts | 5 +- src/utils/importFuncGenerator.ts | 13 +- src/utils/importPaths.ts | 15 +- .../externalInputChecksInts.ts | 5 +- src/warplib/implementations/maths/add.ts | 6 +- src/warplib/implementations/maths/sub.ts | 4 +- .../maths/external_input_check_address.cairo | 2 +- warplib/maths/ge.cairo | 18 +- 153 files changed, 47667 insertions(+), 129 deletions(-) create mode 100644 cairo1/darwin_arm64/corelib/src/warplib.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/integer.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/add.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/add_signed.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/add_signed_unsafe.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/add_unsafe.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/addmod.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/and_.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/bitwise_and.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/bitwise_not.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/bitwise_or.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/bytes_access.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/bytes_conversions.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/div.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/div_signed.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/div_signed_unsafe.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/div_unsafe.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/eq.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/exp.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/exp_signed.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/exp_signed_unsafe.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/exp_unsafe.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/external_input_check_address.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/external_input_check_bool.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/external_input_check_ints.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/ge.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/ge_signed.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/gt.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/gt_signed.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/int_conversions.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/le.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/le_signed.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/lt.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/lt_signed.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/mod.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/mod_signed.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/mul.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/mul_signed.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/mul_signed_unsafe.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/mul_unsafe.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/mulmod.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/negate.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/neq.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/or.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/pow2.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/shl.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/shr.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/shr_signed.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/sub.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/sub_signed.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/sub_signed_unsafe.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/sub_unsafe.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/utils.cairo create mode 100644 cairo1/darwin_arm64/corelib/src/warplib/maths/xor.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/integer.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/add.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/add_signed.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/add_signed_unsafe.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/add_unsafe.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/addmod.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/and_.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/bitwise_and.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/bitwise_not.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/bitwise_or.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/bytes_access.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/bytes_conversions.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/div.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/div_signed.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/div_signed_unsafe.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/div_unsafe.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/eq.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/exp.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/exp_signed.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/exp_signed_unsafe.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/exp_unsafe.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/external_input_check_address.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/external_input_check_bool.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/external_input_check_ints.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/ge.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/ge_signed.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/gt.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/gt_signed.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/int_conversions.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/le.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/le_signed.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/lt.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/lt_signed.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/mod.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/mod_signed.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/mul.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/mul_signed.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/mul_signed_unsafe.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/mul_unsafe.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/mulmod.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/negate.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/neq.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/or.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/pow2.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/shl.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/shr.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/shr_signed.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/sub.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/sub_signed.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/sub_signed_unsafe.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/sub_unsafe.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/utils.cairo create mode 100644 cairo1/linux_x64/corelib/src/warplib/maths/xor.cairo diff --git a/cairo1/darwin_arm64/corelib/src/lib.cairo b/cairo1/darwin_arm64/corelib/src/lib.cairo index 76ca0d430..19ef9a3bb 100644 --- a/cairo1/darwin_arm64/corelib/src/lib.cairo +++ b/cairo1/darwin_arm64/corelib/src/lib.cairo @@ -413,3 +413,13 @@ mod test; // Modules for testing only. mod testing; mod starknet_testing; + +mod warplib; +use warplib::get_u128_try_from_felt_result; +use warplib::u256_from_felts; + +use warplib::maths::warp_add256; +use warplib::maths::warp_external_input_check_address; +use warplib::maths::warp_external_input_check_int256; +use warplib::maths::warp_ge256; +use warplib::maths::warp_sub_unsafe256; diff --git a/cairo1/darwin_arm64/corelib/src/warplib.cairo b/cairo1/darwin_arm64/corelib/src/warplib.cairo new file mode 100644 index 000000000..6e04b1ec5 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib.cairo @@ -0,0 +1,10 @@ +mod integer; +use integer::get_u128_try_from_felt_result; +use integer::u256_from_felts; + +mod maths; +use maths::warp_add256; +use maths::warp_external_input_check_address; +use maths::warp_external_input_check_int256; +use maths::warp_ge256; +use maths::warp_sub_unsafe256; diff --git a/cairo1/darwin_arm64/corelib/src/warplib/integer.cairo b/cairo1/darwin_arm64/corelib/src/warplib/integer.cairo new file mode 100644 index 000000000..071a87cef --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/integer.cairo @@ -0,0 +1,15 @@ +use integer::u128_try_from_felt; +use option::OptionTrait; + +fn u256_from_felts(low_felt: felt, high_felt: felt) -> u256 { + let low_u128: u128 = get_u128_try_from_felt_result(low_felt); + let high_u128: u128 = get_u128_try_from_felt_result(high_felt); + return u256{ low: low_u128, high: high_u128 }; +} + +fn get_u128_try_from_felt_result(value: felt) -> u128 { + let resp = u128_try_from_felt(value); + assert(resp.is_some(), 'Felts too large for u256'); + return resp.unwrap(); +} + diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths.cairo new file mode 100644 index 000000000..09af3e7c3 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths.cairo @@ -0,0 +1,10 @@ +mod add; +use add::warp_add256; +mod external_input_check_address; +use external_input_check_address::warp_external_input_check_address; +mod external_input_check_ints; +use external_input_check_ints::warp_external_input_check_int256; +mod ge; +use ge::warp_ge256; +mod sub_unsafe; +use sub_unsafe::warp_sub_unsafe256; diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/add.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/add.cairo new file mode 100644 index 000000000..62fdc288c --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/add.cairo @@ -0,0 +1,192 @@ +//AUTO-GENERATED + + +fn warp_add8(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add16(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add24(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add32(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add40(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add48(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add56(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add64(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add72(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add80(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add88(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add96(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add104(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add112(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add120(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add128(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add136(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add144(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add152(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add160(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add168(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add176(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add184(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add192(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add200(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add208(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add216(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add224(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add232(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add240(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add248(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add256(lhs: u256, rhs: u256) -> u256{ + return lhs + rhs; +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/add_signed.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/add_signed.cairo new file mode 100644 index 000000000..bd826e796 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/add_signed.cairo @@ -0,0 +1,420 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.math_cmp import is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_add + +func warp_add_signed8{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80); + let (rmsb) = bitwise_and(rhs, 0x80); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180); + assert overflowBits * (overflowBits - 0x180) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xff); + return (res,); +} +func warp_add_signed16{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x8000); + let (rmsb) = bitwise_and(rhs, 0x8000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x18000); + assert overflowBits * (overflowBits - 0x18000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffff); + return (res,); +} +func warp_add_signed24{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x800000); + let (rmsb) = bitwise_and(rhs, 0x800000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x1800000); + assert overflowBits * (overflowBits - 0x1800000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffff); + return (res,); +} +func warp_add_signed32{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80000000); + let (rmsb) = bitwise_and(rhs, 0x80000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180000000); + assert overflowBits * (overflowBits - 0x180000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffff); + return (res,); +} +func warp_add_signed40{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x8000000000); + let (rmsb) = bitwise_and(rhs, 0x8000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x18000000000); + assert overflowBits * (overflowBits - 0x18000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffff); + return (res,); +} +func warp_add_signed48{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x800000000000); + let (rmsb) = bitwise_and(rhs, 0x800000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x1800000000000); + assert overflowBits * (overflowBits - 0x1800000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffff); + return (res,); +} +func warp_add_signed56{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80000000000000); + let (rmsb) = bitwise_and(rhs, 0x80000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180000000000000); + assert overflowBits * (overflowBits - 0x180000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffff); + return (res,); +} +func warp_add_signed64{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x8000000000000000); + let (rmsb) = bitwise_and(rhs, 0x8000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x18000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffff); + return (res,); +} +func warp_add_signed72{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x800000000000000000); + let (rmsb) = bitwise_and(rhs, 0x800000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x1800000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffff); + return (res,); +} +func warp_add_signed80{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x80000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffff); + return (res,); +} +func warp_add_signed88{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x8000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x8000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x18000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffff); + return (res,); +} +func warp_add_signed96{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x800000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x800000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x1800000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed104{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x80000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed112{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x8000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x8000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x18000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed120{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x800000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x800000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x1800000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed128{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x80000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed136{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x8000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x8000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x18000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed144{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x800000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x800000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x1800000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed152{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed160{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x18000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed168{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x1800000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed176{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed184{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x18000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed192{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x1800000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed200{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed208{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x18000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed216{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x1800000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed224{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180000000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed232{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x18000000000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed240{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x1800000000000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed248{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180000000000000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + let (lhs_extend) = bitwise_and(lhs.high, 0x80000000000000000000000000000000); + let (rhs_extend) = bitwise_and(rhs.high, 0x80000000000000000000000000000000); + let (res : Uint256, carry : felt) = uint256_add(lhs, rhs); + let carry_extend = lhs_extend + rhs_extend + carry*0x80000000000000000000000000000000; + let (msb) = bitwise_and(res.high, 0x80000000000000000000000000000000); + let (carry_lsb) = bitwise_and(carry_extend, 0x80000000000000000000000000000000); + assert msb = carry_lsb; + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/add_signed_unsafe.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/add_signed_unsafe.cairo new file mode 100644 index 000000000..4fa063cba --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/add_signed_unsafe.cairo @@ -0,0 +1,165 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.math_cmp import is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_add + +func warp_add_signed_unsafe8{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xff); + return (res,); +} +func warp_add_signed_unsafe16{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffff); + return (res,); +} +func warp_add_signed_unsafe24{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffff); + return (res,); +} +func warp_add_signed_unsafe32{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffff); + return (res,); +} +func warp_add_signed_unsafe40{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffff); + return (res,); +} +func warp_add_signed_unsafe48{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffff); + return (res,); +} +func warp_add_signed_unsafe56{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe64{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe72{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe80{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe88{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe96{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe104{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe112{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe120{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe128{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe136{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe144{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe152{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe160{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe168{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe176{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe184{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe192{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe200{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe208{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe216{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe224{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe232{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe240{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe248{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe256{range_check_ptr}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + let (res : Uint256, _) = uint256_add(lhs, rhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/add_unsafe.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/add_unsafe.cairo new file mode 100644 index 000000000..e45838023 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/add_unsafe.cairo @@ -0,0 +1,131 @@ +//AUTO-GENERATED +use integer::u256_overflowing_add + +fn warp_add_unsafe8(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe16(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe24(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe32(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe40(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe48(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe56(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe64(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe72(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe80(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe88(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe96(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe104(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe112(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe120(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe128(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe136(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe144(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe152(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe160(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe168(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe176(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe184(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe192(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe200(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe208(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe216(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe224(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe232(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe240(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe248(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe256(lhs : u256, rhs : u256) -> u256 { + let (value, _) = u256_overflowing_add(lhs, rhs); + return value; +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/addmod.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/addmod.cairo new file mode 100644 index 000000000..4c87967d0 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/addmod.cairo @@ -0,0 +1,39 @@ +from starkware.cairo.common.uint256 import ( + Uint256, + uint256_unsigned_div_rem, + uint256_add, + uint256_sub, + ALL_ONES, +) +from warplib.maths.utils import felt_to_uint256 + +const SHIFT = 2 ** 128; + +func warp_addmod{range_check_ptr}(x: Uint256, y: Uint256, k: Uint256) -> (res: Uint256) { + alloc_locals; + if (k.high + k.low == 0) { + with_attr error_message("Modulo by zero error") { + assert 1 = 0; + } + } + + let (xy, carry) = uint256_add(x, y); + if (carry == 0) { + let (_, res: Uint256) = uint256_unsigned_div_rem(xy, k); + return (res,); + } + + let uint256_MAX = Uint256(low=ALL_ONES, high=ALL_ONES); + let (overflow) = uint256_sub(uint256_MAX, k); + // carry is zero because k > 0 + let (overflow, _) = uint256_add(overflow, Uint256(low=1, high=0)); + let (_, overflow_rem) = uint256_unsigned_div_rem(overflow, k); + + let (_, xy_rem) = uint256_unsigned_div_rem(xy, k); + + let (res_, _) = uint256_add(xy_rem, overflow_rem); + + let (_, res) = uint256_unsigned_div_rem(res_, k); + + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/and_.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/and_.cairo new file mode 100644 index 000000000..22961dc6c --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/and_.cairo @@ -0,0 +1,4 @@ +func warp_and_(lhs: felt, rhs: felt) -> (res: felt) { + let res = lhs * rhs; + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/bitwise_and.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/bitwise_and.cairo new file mode 100644 index 000000000..2a4fcd65e --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/bitwise_and.cairo @@ -0,0 +1,15 @@ +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_and + +func warp_bitwise_and{bitwise_ptr: BitwiseBuiltin*}(lhs: felt, rhs: felt) -> (res: felt) { + let (res) = bitwise_and(lhs, rhs); + return (res,); +} + +func warp_bitwise_and256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}( + lhs: Uint256, rhs: Uint256 +) -> (res: Uint256) { + let (res) = uint256_and(lhs, rhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/bitwise_not.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/bitwise_not.cairo new file mode 100644 index 000000000..3a9753133 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/bitwise_not.cairo @@ -0,0 +1,133 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_xor +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_not + +func warp_bitwise_not8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xff); + return (res,); +} +func warp_bitwise_not16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffff); + return (res,); +} +func warp_bitwise_not24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffff); + return (res,); +} +func warp_bitwise_not32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffff); + return (res,); +} +func warp_bitwise_not40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffff); + return (res,); +} +func warp_bitwise_not48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffff); + return (res,); +} +func warp_bitwise_not56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffff); + return (res,); +} +func warp_bitwise_not64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffff); + return (res,); +} +func warp_bitwise_not72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffff); + return (res,); +} +func warp_bitwise_not80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not184{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not192{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not200{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not208{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not216{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not224{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not232{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not240{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not248{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not256{range_check_ptr}(op : Uint256) -> (res : Uint256){ + let (res) = uint256_not(op); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/bitwise_or.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/bitwise_or.cairo new file mode 100644 index 000000000..1865ad25c --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/bitwise_or.cairo @@ -0,0 +1,15 @@ +from starkware.cairo.common.bitwise import bitwise_or +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_or + +func warp_bitwise_or{bitwise_ptr: BitwiseBuiltin*}(lhs: felt, rhs: felt) -> (res: felt) { + let (res) = bitwise_or(lhs, rhs); + return (res,); +} + +func warp_bitwise_or256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}( + lhs: Uint256, rhs: Uint256 +) -> (res: Uint256) { + let (res) = uint256_or(lhs, rhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/bytes_access.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/bytes_access.cairo new file mode 100644 index 000000000..f68328ad8 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/bytes_access.cairo @@ -0,0 +1,98 @@ +from warplib.maths.pow2 import pow2 +from starkware.cairo.common.bitwise import bitwise_and + +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256 +from starkware.cairo.common.math import assert_le_felt, assert_nn_le +from starkware.cairo.common.math_cmp import is_le_felt, is_nn_le + +from starkware.cairo.common.serialize import serialize_word + +func byte_accessor{range_check_ptr}(index: felt) -> (offset: felt) { + let (pow2index) = pow2(index * 8); + return (255 * pow2index,); +} + +func byte_at_index_uint256{bitwise_ptr: BitwiseBuiltin*, range_check_ptr}( + base: felt, index: Uint256, width: felt +) -> (res: felt) { + alloc_locals; + + assert index.high = 0; + assert_nn_le(index.low, width - 1); + let index_felt = index.low; + + let index_from_right = width - 1 - index_felt; + + let (byte_accesor_felt) = byte_accessor(index_from_right); + let (slicer) = pow2(index_from_right * 8); + let (res_and) = bitwise_and(base, byte_accesor_felt); + let res = res_and / slicer; + return (res,); +} + +func byte_at_index{bitwise_ptr: BitwiseBuiltin*, range_check_ptr}( + base: felt, index: felt, width: felt +) -> (res: felt) { + alloc_locals; + + assert_nn_le(index, width - 1); + + let index_from_right = width - 1 - index; + + let (byte_accesor_felt) = byte_accessor(index_from_right); + let (slicer) = pow2(index_from_right * 8); + let (res_and) = bitwise_and(base, byte_accesor_felt); + let res = res_and / slicer; + return (res,); +} + +func byte256_at_index{bitwise_ptr: BitwiseBuiltin*, range_check_ptr}( + base: Uint256, index: felt +) -> (res: felt) { + alloc_locals; + assert_nn_le(index, 31); + + let less_than_eq_15 = is_le_felt(index, 15); + if (less_than_eq_15 == 1) { + let index_from_right = 15 - index; + let (byte_accesor_felt) = byte_accessor(index_from_right); + let (slicer) = pow2(index_from_right * 8); + let (res_and) = bitwise_and(base.high, byte_accesor_felt); + let res = res_and / slicer; + return (res,); + } else { + let index_from_right = 31 - index; + let (byte_accesor_felt) = byte_accessor(index_from_right); + let (slicer) = pow2(index_from_right * 8); + let (res_and) = bitwise_and(base.low, byte_accesor_felt); + let res = res_and / slicer; + return (res,); + } +} + +func byte256_at_index_uint256{bitwise_ptr: BitwiseBuiltin*, range_check_ptr}( + base: Uint256, index: Uint256 +) -> (res: felt) { + alloc_locals; + + assert index.high = 0; + assert_nn_le(index.low, 31); + + let less_than_eq_15 = is_le_felt(index.low, 15); + if (less_than_eq_15 == 1) { + let index_from_right = 15 - index.low; + let (byte_accesor_felt) = byte_accessor(index_from_right); + let (slicer) = pow2(index_from_right * 8); + let (res_and) = bitwise_and(base.high, byte_accesor_felt); + let res = res_and / slicer; + return (res,); + } else { + let index_from_right = 31 - index.low; + let (byte_accesor_felt) = byte_accessor(index_from_right); + let (slicer) = pow2(index_from_right * 8); + let (res_and) = bitwise_and(base.low, byte_accesor_felt); + let res = res_and / slicer; + return (res,); + } +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/bytes_conversions.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/bytes_conversions.cairo new file mode 100644 index 000000000..e4e4eb47f --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/bytes_conversions.cairo @@ -0,0 +1,35 @@ +from starkware.cairo.common.uint256 import Uint256, uint256_mul, uint256_unsigned_div_rem +from warplib.maths.pow2 import pow2, u256_pow2 +from warplib.maths.utils import felt_to_uint256 +from starkware.cairo.common.bitwise import bitwise_and, bitwise_not +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin + +const SHIFT = 2 ** 128; + +func warp_bytes_widen(x: felt, widthDiff: felt) -> (res: felt) { + let (multiplier) = pow2(widthDiff); + return (x * multiplier,); +} + +func warp_bytes_widen_256{range_check_ptr}(x: felt, widthDiff: felt) -> (res: Uint256) { + let (in256: Uint256) = felt_to_uint256(x); + let (multiplier) = u256_pow2(widthDiff); + let (res, overflow) = uint256_mul(in256, multiplier); + assert overflow.low = 0; + assert overflow.high = 0; + return (res,); +} + +func warp_bytes_narrow{bitwise_ptr: BitwiseBuiltin*}(x: felt, widthDiff: felt) -> (res: felt) { + let (divisor) = pow2(widthDiff); + let (mask) = bitwise_not(divisor - 1); + let (res) = bitwise_and(x, mask); + return (res / divisor,); +} + +func warp_bytes_narrow_256{range_check_ptr: felt}(x: Uint256, widthDiff: felt) -> (res: felt) { + let (divisor_felt) = pow2(widthDiff); + let (divisor) = felt_to_uint256(divisor_felt); + let (res, _) = uint256_unsigned_div_rem(x, divisor); + return (SHIFT * res.high + res.low,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/div.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/div.cairo new file mode 100644 index 000000000..85c8881a6 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/div.cairo @@ -0,0 +1,28 @@ +from starkware.cairo.common.uint256 import Uint256, uint256_unsigned_div_rem +from warplib.maths.utils import felt_to_uint256 + +const SHIFT = 2 ** 128; + +func warp_div{range_check_ptr}(lhs: felt, rhs: felt) -> (res: felt) { + if (rhs == 0) { + with_attr error_message("Division by zero error") { + assert 1 = 0; + } + } + let (lhs_256) = felt_to_uint256(lhs); + let (rhs_256) = felt_to_uint256(rhs); + let (res256, _) = uint256_unsigned_div_rem(lhs_256, rhs_256); + return (res256.low + SHIFT * res256.high,); +} + +func warp_div256{range_check_ptr}(lhs: Uint256, rhs: Uint256) -> (res: Uint256) { + if (rhs.high == 0) { + if (rhs.low == 0) { + with_attr error_message("Division by zero error") { + assert 1 = 0; + } + } + } + let (res: Uint256, _) = uint256_unsigned_div_rem(lhs, rhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/div_signed.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/div_signed.cairo new file mode 100644 index 000000000..9b0cbe9ef --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/div_signed.cairo @@ -0,0 +1,549 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_signed_div_rem, uint256_eq +from warplib.maths.utils import felt_to_uint256 +from warplib.maths.int_conversions import warp_int8_to_int256, warp_int16_to_int256, warp_int24_to_int256, warp_int32_to_int256, warp_int40_to_int256, warp_int48_to_int256, warp_int56_to_int256, warp_int64_to_int256, warp_int72_to_int256, warp_int80_to_int256, warp_int88_to_int256, warp_int96_to_int256, warp_int104_to_int256, warp_int112_to_int256, warp_int120_to_int256, warp_int128_to_int256, warp_int136_to_int256, warp_int144_to_int256, warp_int152_to_int256, warp_int160_to_int256, warp_int168_to_int256, warp_int176_to_int256, warp_int184_to_int256, warp_int192_to_int256, warp_int200_to_int256, warp_int208_to_int256, warp_int216_to_int256, warp_int224_to_int256, warp_int232_to_int256, warp_int240_to_int256, warp_int248_to_int256, warp_int256_to_int8, warp_int256_to_int16, warp_int256_to_int24, warp_int256_to_int32, warp_int256_to_int40, warp_int256_to_int48, warp_int256_to_int56, warp_int256_to_int64, warp_int256_to_int72, warp_int256_to_int80, warp_int256_to_int88, warp_int256_to_int96, warp_int256_to_int104, warp_int256_to_int112, warp_int256_to_int120, warp_int256_to_int128, warp_int256_to_int136, warp_int256_to_int144, warp_int256_to_int152, warp_int256_to_int160, warp_int256_to_int168, warp_int256_to_int176, warp_int256_to_int184, warp_int256_to_int192, warp_int256_to_int200, warp_int256_to_int208, warp_int256_to_int216, warp_int256_to_int224, warp_int256_to_int232, warp_int256_to_int240, warp_int256_to_int248 +from warplib.maths.mul_signed import warp_mul_signed8,warp_mul_signed16,warp_mul_signed24,warp_mul_signed32,warp_mul_signed40,warp_mul_signed48,warp_mul_signed56,warp_mul_signed64,warp_mul_signed72,warp_mul_signed80,warp_mul_signed88,warp_mul_signed96,warp_mul_signed104,warp_mul_signed112,warp_mul_signed120,warp_mul_signed128,warp_mul_signed136,warp_mul_signed144,warp_mul_signed152,warp_mul_signed160,warp_mul_signed168,warp_mul_signed176,warp_mul_signed184,warp_mul_signed192,warp_mul_signed200,warp_mul_signed208,warp_mul_signed216,warp_mul_signed224,warp_mul_signed232,warp_mul_signed240,warp_mul_signed248,warp_mul_signed256 + +func warp_div_signed8{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xff){ + let (res : felt) = warp_mul_signed8(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int8_to_int256(lhs); + let (rhs_256) = warp_int8_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int8(res256); + return (truncated,); +} +func warp_div_signed16{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffff){ + let (res : felt) = warp_mul_signed16(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int16_to_int256(lhs); + let (rhs_256) = warp_int16_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int16(res256); + return (truncated,); +} +func warp_div_signed24{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffff){ + let (res : felt) = warp_mul_signed24(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int24_to_int256(lhs); + let (rhs_256) = warp_int24_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int24(res256); + return (truncated,); +} +func warp_div_signed32{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffff){ + let (res : felt) = warp_mul_signed32(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int32_to_int256(lhs); + let (rhs_256) = warp_int32_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int32(res256); + return (truncated,); +} +func warp_div_signed40{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffff){ + let (res : felt) = warp_mul_signed40(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int40_to_int256(lhs); + let (rhs_256) = warp_int40_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int40(res256); + return (truncated,); +} +func warp_div_signed48{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffff){ + let (res : felt) = warp_mul_signed48(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int48_to_int256(lhs); + let (rhs_256) = warp_int48_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int48(res256); + return (truncated,); +} +func warp_div_signed56{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffff){ + let (res : felt) = warp_mul_signed56(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int56_to_int256(lhs); + let (rhs_256) = warp_int56_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int56(res256); + return (truncated,); +} +func warp_div_signed64{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffff){ + let (res : felt) = warp_mul_signed64(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int64_to_int256(lhs); + let (rhs_256) = warp_int64_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int64(res256); + return (truncated,); +} +func warp_div_signed72{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffff){ + let (res : felt) = warp_mul_signed72(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int72_to_int256(lhs); + let (rhs_256) = warp_int72_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int72(res256); + return (truncated,); +} +func warp_div_signed80{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffff){ + let (res : felt) = warp_mul_signed80(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int80_to_int256(lhs); + let (rhs_256) = warp_int80_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int80(res256); + return (truncated,); +} +func warp_div_signed88{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed88(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int88_to_int256(lhs); + let (rhs_256) = warp_int88_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int88(res256); + return (truncated,); +} +func warp_div_signed96{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed96(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int96_to_int256(lhs); + let (rhs_256) = warp_int96_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int96(res256); + return (truncated,); +} +func warp_div_signed104{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed104(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int104_to_int256(lhs); + let (rhs_256) = warp_int104_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int104(res256); + return (truncated,); +} +func warp_div_signed112{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed112(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int112_to_int256(lhs); + let (rhs_256) = warp_int112_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int112(res256); + return (truncated,); +} +func warp_div_signed120{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed120(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int120_to_int256(lhs); + let (rhs_256) = warp_int120_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int120(res256); + return (truncated,); +} +func warp_div_signed128{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed128(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int128_to_int256(lhs); + let (rhs_256) = warp_int128_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int128(res256); + return (truncated,); +} +func warp_div_signed136{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed136(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int136_to_int256(lhs); + let (rhs_256) = warp_int136_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int136(res256); + return (truncated,); +} +func warp_div_signed144{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed144(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int144_to_int256(lhs); + let (rhs_256) = warp_int144_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int144(res256); + return (truncated,); +} +func warp_div_signed152{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed152(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int152_to_int256(lhs); + let (rhs_256) = warp_int152_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int152(res256); + return (truncated,); +} +func warp_div_signed160{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed160(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int160_to_int256(lhs); + let (rhs_256) = warp_int160_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int160(res256); + return (truncated,); +} +func warp_div_signed168{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed168(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int168_to_int256(lhs); + let (rhs_256) = warp_int168_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int168(res256); + return (truncated,); +} +func warp_div_signed176{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed176(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int176_to_int256(lhs); + let (rhs_256) = warp_int176_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int176(res256); + return (truncated,); +} +func warp_div_signed184{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed184(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int184_to_int256(lhs); + let (rhs_256) = warp_int184_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int184(res256); + return (truncated,); +} +func warp_div_signed192{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed192(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int192_to_int256(lhs); + let (rhs_256) = warp_int192_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int192(res256); + return (truncated,); +} +func warp_div_signed200{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed200(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int200_to_int256(lhs); + let (rhs_256) = warp_int200_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int200(res256); + return (truncated,); +} +func warp_div_signed208{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed208(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int208_to_int256(lhs); + let (rhs_256) = warp_int208_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int208(res256); + return (truncated,); +} +func warp_div_signed216{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed216(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int216_to_int256(lhs); + let (rhs_256) = warp_int216_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int216(res256); + return (truncated,); +} +func warp_div_signed224{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed224(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int224_to_int256(lhs); + let (rhs_256) = warp_int224_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int224(res256); + return (truncated,); +} +func warp_div_signed232{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed232(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int232_to_int256(lhs); + let (rhs_256) = warp_int232_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int232(res256); + return (truncated,); +} +func warp_div_signed240{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed240(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int240_to_int256(lhs); + let (rhs_256) = warp_int240_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int240(res256); + return (truncated,); +} +func warp_div_signed248{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed248(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int248_to_int256(lhs); + let (rhs_256) = warp_int248_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int248(res256); + return (truncated,); +} +func warp_div_signed256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + if (rhs.high == 0 and rhs.low == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + let (is_minus_one) = uint256_eq(rhs, Uint256(0xffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffff)); + if (is_minus_one == 1){ + let (res : Uint256) = warp_mul_signed256(lhs, rhs); + return (res,); + } + let (res : Uint256, _) = uint256_signed_div_rem(lhs, rhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/div_signed_unsafe.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/div_signed_unsafe.cairo new file mode 100644 index 000000000..eb268cc68 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/div_signed_unsafe.cairo @@ -0,0 +1,549 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_signed_div_rem, uint256_eq +from warplib.maths.utils import felt_to_uint256 +from warplib.maths.int_conversions import warp_int8_to_int256, warp_int16_to_int256, warp_int24_to_int256, warp_int32_to_int256, warp_int40_to_int256, warp_int48_to_int256, warp_int56_to_int256, warp_int64_to_int256, warp_int72_to_int256, warp_int80_to_int256, warp_int88_to_int256, warp_int96_to_int256, warp_int104_to_int256, warp_int112_to_int256, warp_int120_to_int256, warp_int128_to_int256, warp_int136_to_int256, warp_int144_to_int256, warp_int152_to_int256, warp_int160_to_int256, warp_int168_to_int256, warp_int176_to_int256, warp_int184_to_int256, warp_int192_to_int256, warp_int200_to_int256, warp_int208_to_int256, warp_int216_to_int256, warp_int224_to_int256, warp_int232_to_int256, warp_int240_to_int256, warp_int248_to_int256, warp_int256_to_int8, warp_int256_to_int16, warp_int256_to_int24, warp_int256_to_int32, warp_int256_to_int40, warp_int256_to_int48, warp_int256_to_int56, warp_int256_to_int64, warp_int256_to_int72, warp_int256_to_int80, warp_int256_to_int88, warp_int256_to_int96, warp_int256_to_int104, warp_int256_to_int112, warp_int256_to_int120, warp_int256_to_int128, warp_int256_to_int136, warp_int256_to_int144, warp_int256_to_int152, warp_int256_to_int160, warp_int256_to_int168, warp_int256_to_int176, warp_int256_to_int184, warp_int256_to_int192, warp_int256_to_int200, warp_int256_to_int208, warp_int256_to_int216, warp_int256_to_int224, warp_int256_to_int232, warp_int256_to_int240, warp_int256_to_int248 +from warplib.maths.mul_signed_unsafe import warp_mul_signed_unsafe8,warp_mul_signed_unsafe16,warp_mul_signed_unsafe24,warp_mul_signed_unsafe32,warp_mul_signed_unsafe40,warp_mul_signed_unsafe48,warp_mul_signed_unsafe56,warp_mul_signed_unsafe64,warp_mul_signed_unsafe72,warp_mul_signed_unsafe80,warp_mul_signed_unsafe88,warp_mul_signed_unsafe96,warp_mul_signed_unsafe104,warp_mul_signed_unsafe112,warp_mul_signed_unsafe120,warp_mul_signed_unsafe128,warp_mul_signed_unsafe136,warp_mul_signed_unsafe144,warp_mul_signed_unsafe152,warp_mul_signed_unsafe160,warp_mul_signed_unsafe168,warp_mul_signed_unsafe176,warp_mul_signed_unsafe184,warp_mul_signed_unsafe192,warp_mul_signed_unsafe200,warp_mul_signed_unsafe208,warp_mul_signed_unsafe216,warp_mul_signed_unsafe224,warp_mul_signed_unsafe232,warp_mul_signed_unsafe240,warp_mul_signed_unsafe248,warp_mul_signed_unsafe256 + +func warp_div_signed_unsafe8{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xff){ + let (res : felt) = warp_mul_signed_unsafe8(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int8_to_int256(lhs); + let (rhs_256) = warp_int8_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int8(res256); + return (truncated,); +} +func warp_div_signed_unsafe16{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffff){ + let (res : felt) = warp_mul_signed_unsafe16(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int16_to_int256(lhs); + let (rhs_256) = warp_int16_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int16(res256); + return (truncated,); +} +func warp_div_signed_unsafe24{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffff){ + let (res : felt) = warp_mul_signed_unsafe24(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int24_to_int256(lhs); + let (rhs_256) = warp_int24_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int24(res256); + return (truncated,); +} +func warp_div_signed_unsafe32{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffff){ + let (res : felt) = warp_mul_signed_unsafe32(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int32_to_int256(lhs); + let (rhs_256) = warp_int32_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int32(res256); + return (truncated,); +} +func warp_div_signed_unsafe40{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffff){ + let (res : felt) = warp_mul_signed_unsafe40(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int40_to_int256(lhs); + let (rhs_256) = warp_int40_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int40(res256); + return (truncated,); +} +func warp_div_signed_unsafe48{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe48(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int48_to_int256(lhs); + let (rhs_256) = warp_int48_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int48(res256); + return (truncated,); +} +func warp_div_signed_unsafe56{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe56(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int56_to_int256(lhs); + let (rhs_256) = warp_int56_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int56(res256); + return (truncated,); +} +func warp_div_signed_unsafe64{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe64(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int64_to_int256(lhs); + let (rhs_256) = warp_int64_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int64(res256); + return (truncated,); +} +func warp_div_signed_unsafe72{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe72(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int72_to_int256(lhs); + let (rhs_256) = warp_int72_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int72(res256); + return (truncated,); +} +func warp_div_signed_unsafe80{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe80(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int80_to_int256(lhs); + let (rhs_256) = warp_int80_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int80(res256); + return (truncated,); +} +func warp_div_signed_unsafe88{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe88(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int88_to_int256(lhs); + let (rhs_256) = warp_int88_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int88(res256); + return (truncated,); +} +func warp_div_signed_unsafe96{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe96(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int96_to_int256(lhs); + let (rhs_256) = warp_int96_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int96(res256); + return (truncated,); +} +func warp_div_signed_unsafe104{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe104(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int104_to_int256(lhs); + let (rhs_256) = warp_int104_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int104(res256); + return (truncated,); +} +func warp_div_signed_unsafe112{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe112(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int112_to_int256(lhs); + let (rhs_256) = warp_int112_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int112(res256); + return (truncated,); +} +func warp_div_signed_unsafe120{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe120(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int120_to_int256(lhs); + let (rhs_256) = warp_int120_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int120(res256); + return (truncated,); +} +func warp_div_signed_unsafe128{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe128(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int128_to_int256(lhs); + let (rhs_256) = warp_int128_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int128(res256); + return (truncated,); +} +func warp_div_signed_unsafe136{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe136(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int136_to_int256(lhs); + let (rhs_256) = warp_int136_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int136(res256); + return (truncated,); +} +func warp_div_signed_unsafe144{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe144(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int144_to_int256(lhs); + let (rhs_256) = warp_int144_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int144(res256); + return (truncated,); +} +func warp_div_signed_unsafe152{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe152(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int152_to_int256(lhs); + let (rhs_256) = warp_int152_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int152(res256); + return (truncated,); +} +func warp_div_signed_unsafe160{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe160(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int160_to_int256(lhs); + let (rhs_256) = warp_int160_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int160(res256); + return (truncated,); +} +func warp_div_signed_unsafe168{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe168(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int168_to_int256(lhs); + let (rhs_256) = warp_int168_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int168(res256); + return (truncated,); +} +func warp_div_signed_unsafe176{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe176(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int176_to_int256(lhs); + let (rhs_256) = warp_int176_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int176(res256); + return (truncated,); +} +func warp_div_signed_unsafe184{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe184(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int184_to_int256(lhs); + let (rhs_256) = warp_int184_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int184(res256); + return (truncated,); +} +func warp_div_signed_unsafe192{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe192(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int192_to_int256(lhs); + let (rhs_256) = warp_int192_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int192(res256); + return (truncated,); +} +func warp_div_signed_unsafe200{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe200(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int200_to_int256(lhs); + let (rhs_256) = warp_int200_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int200(res256); + return (truncated,); +} +func warp_div_signed_unsafe208{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe208(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int208_to_int256(lhs); + let (rhs_256) = warp_int208_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int208(res256); + return (truncated,); +} +func warp_div_signed_unsafe216{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe216(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int216_to_int256(lhs); + let (rhs_256) = warp_int216_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int216(res256); + return (truncated,); +} +func warp_div_signed_unsafe224{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe224(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int224_to_int256(lhs); + let (rhs_256) = warp_int224_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int224(res256); + return (truncated,); +} +func warp_div_signed_unsafe232{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe232(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int232_to_int256(lhs); + let (rhs_256) = warp_int232_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int232(res256); + return (truncated,); +} +func warp_div_signed_unsafe240{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe240(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int240_to_int256(lhs); + let (rhs_256) = warp_int240_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int240(res256); + return (truncated,); +} +func warp_div_signed_unsafe248{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe248(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int248_to_int256(lhs); + let (rhs_256) = warp_int248_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int248(res256); + return (truncated,); +} +func warp_div_signed_unsafe256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + if (rhs.high == 0 and rhs.low == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + let (is_minus_one) = uint256_eq(rhs, Uint256(0xffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffff)); + if (is_minus_one == 1){ + let (res : Uint256) = warp_mul_signed_unsafe256(lhs, rhs); + return (res,); + } + let (res : Uint256, _) = uint256_signed_div_rem(lhs, rhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/div_unsafe.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/div_unsafe.cairo new file mode 100644 index 000000000..ca6221e23 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/div_unsafe.cairo @@ -0,0 +1,28 @@ +from starkware.cairo.common.uint256 import Uint256, uint256_unsigned_div_rem +from warplib.maths.utils import felt_to_uint256 + +const SHIFT = 2 ** 128; + +func warp_div_unsafe{range_check_ptr}(lhs: felt, rhs: felt) -> (res: felt) { + if (rhs == 0) { + with_attr error_message("Division by zero error") { + assert 1 = 0; + } + } + let (lhs_256) = felt_to_uint256(lhs); + let (rhs_256) = felt_to_uint256(rhs); + let (res256, _) = uint256_unsigned_div_rem(lhs_256, rhs_256); + return (res256.low + SHIFT * res256.high,); +} + +func warp_div_unsafe256{range_check_ptr}(lhs: Uint256, rhs: Uint256) -> (res: Uint256) { + if (rhs.high == 0) { + if (rhs.low == 0) { + with_attr error_message("Division by zero error") { + assert 1 = 0; + } + } + } + let (res: Uint256, _) = uint256_unsigned_div_rem(lhs, rhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/eq.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/eq.cairo new file mode 100644 index 000000000..774a18dad --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/eq.cairo @@ -0,0 +1,14 @@ +from starkware.cairo.common.uint256 import Uint256, uint256_eq + +func warp_eq(lhs: felt, rhs: felt) -> (result: felt) { + if (lhs == rhs) { + return (1,); + } else { + return (0,); + } +} + +func warp_eq256{range_check_ptr}(lhs: Uint256, rhs: Uint256) -> (res: felt) { + let (res) = uint256_eq(lhs, rhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/exp.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/exp.cairo new file mode 100644 index 000000000..ac694d46c --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/exp.cairo @@ -0,0 +1,1502 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_sub +from warplib.maths.mul import warp_mul8, warp_mul16, warp_mul24, warp_mul32, warp_mul40, warp_mul48, warp_mul56, warp_mul64, warp_mul72, warp_mul80, warp_mul88, warp_mul96, warp_mul104, warp_mul112, warp_mul120, warp_mul128, warp_mul136, warp_mul144, warp_mul152, warp_mul160, warp_mul168, warp_mul176, warp_mul184, warp_mul192, warp_mul200, warp_mul208, warp_mul216, warp_mul224, warp_mul232, warp_mul240, warp_mul248, warp_mul256 + +func _repeated_multiplication8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication8(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul8(op, x); + return (res,); + } +} +func warp_exp8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication8(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_8(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul8(op, x); + return (res,); +} +func warp_exp_wide8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_8(lhs, rhs); + return (res,); +} +func _repeated_multiplication16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication16(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul16(op, x); + return (res,); + } +} +func warp_exp16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication16(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_16(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul16(op, x); + return (res,); +} +func warp_exp_wide16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_16(lhs, rhs); + return (res,); +} +func _repeated_multiplication24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication24(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul24(op, x); + return (res,); + } +} +func warp_exp24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication24(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_24(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul24(op, x); + return (res,); +} +func warp_exp_wide24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_24(lhs, rhs); + return (res,); +} +func _repeated_multiplication32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication32(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul32(op, x); + return (res,); + } +} +func warp_exp32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication32(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_32(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul32(op, x); + return (res,); +} +func warp_exp_wide32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_32(lhs, rhs); + return (res,); +} +func _repeated_multiplication40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication40(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul40(op, x); + return (res,); + } +} +func warp_exp40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication40(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_40(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul40(op, x); + return (res,); +} +func warp_exp_wide40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_40(lhs, rhs); + return (res,); +} +func _repeated_multiplication48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication48(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul48(op, x); + return (res,); + } +} +func warp_exp48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication48(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_48(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul48(op, x); + return (res,); +} +func warp_exp_wide48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_48(lhs, rhs); + return (res,); +} +func _repeated_multiplication56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication56(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul56(op, x); + return (res,); + } +} +func warp_exp56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication56(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_56(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul56(op, x); + return (res,); +} +func warp_exp_wide56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_56(lhs, rhs); + return (res,); +} +func _repeated_multiplication64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication64(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul64(op, x); + return (res,); + } +} +func warp_exp64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication64(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_64(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul64(op, x); + return (res,); +} +func warp_exp_wide64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_64(lhs, rhs); + return (res,); +} +func _repeated_multiplication72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication72(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul72(op, x); + return (res,); + } +} +func warp_exp72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication72(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_72(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul72(op, x); + return (res,); +} +func warp_exp_wide72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_72(lhs, rhs); + return (res,); +} +func _repeated_multiplication80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication80(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul80(op, x); + return (res,); + } +} +func warp_exp80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication80(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_80(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul80(op, x); + return (res,); +} +func warp_exp_wide80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_80(lhs, rhs); + return (res,); +} +func _repeated_multiplication88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication88(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul88(op, x); + return (res,); + } +} +func warp_exp88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication88(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_88(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul88(op, x); + return (res,); +} +func warp_exp_wide88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_88(lhs, rhs); + return (res,); +} +func _repeated_multiplication96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication96(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul96(op, x); + return (res,); + } +} +func warp_exp96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication96(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_96(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul96(op, x); + return (res,); +} +func warp_exp_wide96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_96(lhs, rhs); + return (res,); +} +func _repeated_multiplication104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication104(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul104(op, x); + return (res,); + } +} +func warp_exp104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication104(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_104(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul104(op, x); + return (res,); +} +func warp_exp_wide104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_104(lhs, rhs); + return (res,); +} +func _repeated_multiplication112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication112(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul112(op, x); + return (res,); + } +} +func warp_exp112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication112(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_112(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul112(op, x); + return (res,); +} +func warp_exp_wide112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_112(lhs, rhs); + return (res,); +} +func _repeated_multiplication120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication120(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul120(op, x); + return (res,); + } +} +func warp_exp120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication120(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_120(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul120(op, x); + return (res,); +} +func warp_exp_wide120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_120(lhs, rhs); + return (res,); +} +func _repeated_multiplication128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication128(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul128(op, x); + return (res,); + } +} +func warp_exp128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication128(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_128(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul128(op, x); + return (res,); +} +func warp_exp_wide128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_128(lhs, rhs); + return (res,); +} +func _repeated_multiplication136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication136(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul136(op, x); + return (res,); + } +} +func warp_exp136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication136(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_136(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul136(op, x); + return (res,); +} +func warp_exp_wide136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_136(lhs, rhs); + return (res,); +} +func _repeated_multiplication144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication144(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul144(op, x); + return (res,); + } +} +func warp_exp144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication144(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_144(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul144(op, x); + return (res,); +} +func warp_exp_wide144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_144(lhs, rhs); + return (res,); +} +func _repeated_multiplication152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication152(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul152(op, x); + return (res,); + } +} +func warp_exp152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication152(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_152(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul152(op, x); + return (res,); +} +func warp_exp_wide152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_152(lhs, rhs); + return (res,); +} +func _repeated_multiplication160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication160(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul160(op, x); + return (res,); + } +} +func warp_exp160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication160(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_160(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul160(op, x); + return (res,); +} +func warp_exp_wide160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_160(lhs, rhs); + return (res,); +} +func _repeated_multiplication168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication168(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul168(op, x); + return (res,); + } +} +func warp_exp168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication168(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_168(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul168(op, x); + return (res,); +} +func warp_exp_wide168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_168(lhs, rhs); + return (res,); +} +func _repeated_multiplication176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication176(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul176(op, x); + return (res,); + } +} +func warp_exp176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication176(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_176(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul176(op, x); + return (res,); +} +func warp_exp_wide176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_176(lhs, rhs); + return (res,); +} +func _repeated_multiplication184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication184(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul184(op, x); + return (res,); + } +} +func warp_exp184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication184(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_184(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul184(op, x); + return (res,); +} +func warp_exp_wide184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_184(lhs, rhs); + return (res,); +} +func _repeated_multiplication192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication192(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul192(op, x); + return (res,); + } +} +func warp_exp192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication192(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_192(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul192(op, x); + return (res,); +} +func warp_exp_wide192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_192(lhs, rhs); + return (res,); +} +func _repeated_multiplication200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication200(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul200(op, x); + return (res,); + } +} +func warp_exp200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication200(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_200(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul200(op, x); + return (res,); +} +func warp_exp_wide200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_200(lhs, rhs); + return (res,); +} +func _repeated_multiplication208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication208(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul208(op, x); + return (res,); + } +} +func warp_exp208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication208(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_208(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul208(op, x); + return (res,); +} +func warp_exp_wide208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_208(lhs, rhs); + return (res,); +} +func _repeated_multiplication216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication216(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul216(op, x); + return (res,); + } +} +func warp_exp216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication216(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_216(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul216(op, x); + return (res,); +} +func warp_exp_wide216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_216(lhs, rhs); + return (res,); +} +func _repeated_multiplication224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication224(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul224(op, x); + return (res,); + } +} +func warp_exp224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication224(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_224(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul224(op, x); + return (res,); +} +func warp_exp_wide224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_224(lhs, rhs); + return (res,); +} +func _repeated_multiplication232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication232(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul232(op, x); + return (res,); + } +} +func warp_exp232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication232(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_232(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul232(op, x); + return (res,); +} +func warp_exp_wide232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_232(lhs, rhs); + return (res,); +} +func _repeated_multiplication240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication240(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul240(op, x); + return (res,); + } +} +func warp_exp240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication240(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_240(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul240(op, x); + return (res,); +} +func warp_exp_wide240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_240(lhs, rhs); + return (res,); +} +func _repeated_multiplication248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication248(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul248(op, x); + return (res,); + } +} +func warp_exp248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication248(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_248(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul248(op, x); + return (res,); +} +func warp_exp_wide248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_248(lhs, rhs); + return (res,); +} +func _repeated_multiplication256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : Uint256, count : felt) -> (res : Uint256){ + if (count == 0){ + return (Uint256(1, 0),); + } + let (x) = _repeated_multiplication256(op, count - 1); + let (res) = warp_mul256(op, x); + return (res,); +} +func warp_exp256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : felt) -> (res : Uint256){ + if (rhs == 0){ + return (Uint256(1, 0),); + } + if (lhs.high == 0){ + if (lhs.low * (lhs.low - 1) == 0){ + return (lhs,); + } + } + let (res) = _repeated_multiplication256(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : Uint256, count : Uint256) -> (res : Uint256){ + if (count.low == 0 and count.high == 0){ + return (Uint256(1, 0),); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_256(op, decr); + let (res) = warp_mul256(op, x); + return (res,); +} +func warp_exp_wide256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + if (rhs.high == 0 and rhs.low == 0){ + return (Uint256(1, 0),); + } + if (lhs.high == 0 and lhs.low * (lhs.low - 1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_256(lhs, rhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/exp_signed.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/exp_signed.cairo new file mode 100644 index 000000000..e33290ab4 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/exp_signed.cairo @@ -0,0 +1,1758 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_sub +from warplib.maths.mul_signed import warp_mul_signed8, warp_mul_signed16, warp_mul_signed24, warp_mul_signed32, warp_mul_signed40, warp_mul_signed48, warp_mul_signed56, warp_mul_signed64, warp_mul_signed72, warp_mul_signed80, warp_mul_signed88, warp_mul_signed96, warp_mul_signed104, warp_mul_signed112, warp_mul_signed120, warp_mul_signed128, warp_mul_signed136, warp_mul_signed144, warp_mul_signed152, warp_mul_signed160, warp_mul_signed168, warp_mul_signed176, warp_mul_signed184, warp_mul_signed192, warp_mul_signed200, warp_mul_signed208, warp_mul_signed216, warp_mul_signed224, warp_mul_signed232, warp_mul_signed240, warp_mul_signed248, warp_mul_signed256 + +func _repeated_multiplication8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication8(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed8(op, x); + return (res,); + } +} +func warp_exp_signed8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xe,); +} + let (res) = _repeated_multiplication8(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_8(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed8(op, x); + return (res,); +} +func warp_exp_wide_signed8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xe,); +} + let (res) = _repeated_multiplication_256_8(lhs, rhs); + return (res,); +} +func _repeated_multiplication16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication16(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed16(op, x); + return (res,); + } +} +func warp_exp_signed16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfe,); +} + let (res) = _repeated_multiplication16(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_16(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed16(op, x); + return (res,); +} +func warp_exp_wide_signed16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfe,); +} + let (res) = _repeated_multiplication_256_16(lhs, rhs); + return (res,); +} +func _repeated_multiplication24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication24(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed24(op, x); + return (res,); + } +} +func warp_exp_signed24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffe,); +} + let (res) = _repeated_multiplication24(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_24(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed24(op, x); + return (res,); +} +func warp_exp_wide_signed24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffe,); +} + let (res) = _repeated_multiplication_256_24(lhs, rhs); + return (res,); +} +func _repeated_multiplication32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication32(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed32(op, x); + return (res,); + } +} +func warp_exp_signed32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffe,); +} + let (res) = _repeated_multiplication32(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_32(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed32(op, x); + return (res,); +} +func warp_exp_wide_signed32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffe,); +} + let (res) = _repeated_multiplication_256_32(lhs, rhs); + return (res,); +} +func _repeated_multiplication40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication40(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed40(op, x); + return (res,); + } +} +func warp_exp_signed40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffe,); +} + let (res) = _repeated_multiplication40(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_40(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed40(op, x); + return (res,); +} +func warp_exp_wide_signed40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffe,); +} + let (res) = _repeated_multiplication_256_40(lhs, rhs); + return (res,); +} +func _repeated_multiplication48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication48(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed48(op, x); + return (res,); + } +} +func warp_exp_signed48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffe,); +} + let (res) = _repeated_multiplication48(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_48(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed48(op, x); + return (res,); +} +func warp_exp_wide_signed48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffe,); +} + let (res) = _repeated_multiplication_256_48(lhs, rhs); + return (res,); +} +func _repeated_multiplication56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication56(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed56(op, x); + return (res,); + } +} +func warp_exp_signed56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffe,); +} + let (res) = _repeated_multiplication56(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_56(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed56(op, x); + return (res,); +} +func warp_exp_wide_signed56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffe,); +} + let (res) = _repeated_multiplication_256_56(lhs, rhs); + return (res,); +} +func _repeated_multiplication64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication64(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed64(op, x); + return (res,); + } +} +func warp_exp_signed64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffe,); +} + let (res) = _repeated_multiplication64(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_64(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed64(op, x); + return (res,); +} +func warp_exp_wide_signed64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffe,); +} + let (res) = _repeated_multiplication_256_64(lhs, rhs); + return (res,); +} +func _repeated_multiplication72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication72(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed72(op, x); + return (res,); + } +} +func warp_exp_signed72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffe,); +} + let (res) = _repeated_multiplication72(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_72(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed72(op, x); + return (res,); +} +func warp_exp_wide_signed72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffe,); +} + let (res) = _repeated_multiplication_256_72(lhs, rhs); + return (res,); +} +func _repeated_multiplication80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication80(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed80(op, x); + return (res,); + } +} +func warp_exp_signed80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffe,); +} + let (res) = _repeated_multiplication80(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_80(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed80(op, x); + return (res,); +} +func warp_exp_wide_signed80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffe,); +} + let (res) = _repeated_multiplication_256_80(lhs, rhs); + return (res,); +} +func _repeated_multiplication88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication88(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed88(op, x); + return (res,); + } +} +func warp_exp_signed88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffe,); +} + let (res) = _repeated_multiplication88(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_88(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed88(op, x); + return (res,); +} +func warp_exp_wide_signed88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffe,); +} + let (res) = _repeated_multiplication_256_88(lhs, rhs); + return (res,); +} +func _repeated_multiplication96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication96(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed96(op, x); + return (res,); + } +} +func warp_exp_signed96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffe,); +} + let (res) = _repeated_multiplication96(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_96(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed96(op, x); + return (res,); +} +func warp_exp_wide_signed96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffe,); +} + let (res) = _repeated_multiplication_256_96(lhs, rhs); + return (res,); +} +func _repeated_multiplication104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication104(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed104(op, x); + return (res,); + } +} +func warp_exp_signed104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffe,); +} + let (res) = _repeated_multiplication104(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_104(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed104(op, x); + return (res,); +} +func warp_exp_wide_signed104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffe,); +} + let (res) = _repeated_multiplication_256_104(lhs, rhs); + return (res,); +} +func _repeated_multiplication112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication112(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed112(op, x); + return (res,); + } +} +func warp_exp_signed112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffe,); +} + let (res) = _repeated_multiplication112(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_112(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed112(op, x); + return (res,); +} +func warp_exp_wide_signed112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffe,); +} + let (res) = _repeated_multiplication_256_112(lhs, rhs); + return (res,); +} +func _repeated_multiplication120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication120(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed120(op, x); + return (res,); + } +} +func warp_exp_signed120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffe,); +} + let (res) = _repeated_multiplication120(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_120(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed120(op, x); + return (res,); +} +func warp_exp_wide_signed120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_120(lhs, rhs); + return (res,); +} +func _repeated_multiplication128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication128(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed128(op, x); + return (res,); + } +} +func warp_exp_signed128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffe,); +} + let (res) = _repeated_multiplication128(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_128(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed128(op, x); + return (res,); +} +func warp_exp_wide_signed128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_128(lhs, rhs); + return (res,); +} +func _repeated_multiplication136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication136(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed136(op, x); + return (res,); + } +} +func warp_exp_signed136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffe,); +} + let (res) = _repeated_multiplication136(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_136(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed136(op, x); + return (res,); +} +func warp_exp_wide_signed136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_136(lhs, rhs); + return (res,); +} +func _repeated_multiplication144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication144(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed144(op, x); + return (res,); + } +} +func warp_exp_signed144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffe,); +} + let (res) = _repeated_multiplication144(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_144(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed144(op, x); + return (res,); +} +func warp_exp_wide_signed144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_144(lhs, rhs); + return (res,); +} +func _repeated_multiplication152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication152(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed152(op, x); + return (res,); + } +} +func warp_exp_signed152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffe,); +} + let (res) = _repeated_multiplication152(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_152(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed152(op, x); + return (res,); +} +func warp_exp_wide_signed152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_152(lhs, rhs); + return (res,); +} +func _repeated_multiplication160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication160(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed160(op, x); + return (res,); + } +} +func warp_exp_signed160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffe,); +} + let (res) = _repeated_multiplication160(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_160(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed160(op, x); + return (res,); +} +func warp_exp_wide_signed160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_160(lhs, rhs); + return (res,); +} +func _repeated_multiplication168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication168(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed168(op, x); + return (res,); + } +} +func warp_exp_signed168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication168(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_168(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed168(op, x); + return (res,); +} +func warp_exp_wide_signed168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_168(lhs, rhs); + return (res,); +} +func _repeated_multiplication176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication176(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed176(op, x); + return (res,); + } +} +func warp_exp_signed176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication176(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_176(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed176(op, x); + return (res,); +} +func warp_exp_wide_signed176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_176(lhs, rhs); + return (res,); +} +func _repeated_multiplication184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication184(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed184(op, x); + return (res,); + } +} +func warp_exp_signed184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication184(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_184(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed184(op, x); + return (res,); +} +func warp_exp_wide_signed184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_184(lhs, rhs); + return (res,); +} +func _repeated_multiplication192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication192(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed192(op, x); + return (res,); + } +} +func warp_exp_signed192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication192(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_192(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed192(op, x); + return (res,); +} +func warp_exp_wide_signed192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_192(lhs, rhs); + return (res,); +} +func _repeated_multiplication200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication200(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed200(op, x); + return (res,); + } +} +func warp_exp_signed200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication200(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_200(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed200(op, x); + return (res,); +} +func warp_exp_wide_signed200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_200(lhs, rhs); + return (res,); +} +func _repeated_multiplication208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication208(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed208(op, x); + return (res,); + } +} +func warp_exp_signed208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication208(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_208(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed208(op, x); + return (res,); +} +func warp_exp_wide_signed208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_208(lhs, rhs); + return (res,); +} +func _repeated_multiplication216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication216(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed216(op, x); + return (res,); + } +} +func warp_exp_signed216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication216(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_216(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed216(op, x); + return (res,); +} +func warp_exp_wide_signed216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_216(lhs, rhs); + return (res,); +} +func _repeated_multiplication224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication224(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed224(op, x); + return (res,); + } +} +func warp_exp_signed224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication224(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_224(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed224(op, x); + return (res,); +} +func warp_exp_wide_signed224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_224(lhs, rhs); + return (res,); +} +func _repeated_multiplication232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication232(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed232(op, x); + return (res,); + } +} +func warp_exp_signed232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication232(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_232(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed232(op, x); + return (res,); +} +func warp_exp_wide_signed232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_232(lhs, rhs); + return (res,); +} +func _repeated_multiplication240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication240(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed240(op, x); + return (res,); + } +} +func warp_exp_signed240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication240(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_240(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed240(op, x); + return (res,); +} +func warp_exp_wide_signed240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_240(lhs, rhs); + return (res,); +} +func _repeated_multiplication248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication248(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed248(op, x); + return (res,); + } +} +func warp_exp_signed248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication248(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_248(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed248(op, x); + return (res,); +} +func warp_exp_wide_signed248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_248(lhs, rhs); + return (res,); +} +func _repeated_multiplication256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : Uint256, count : felt) -> (res : Uint256){ + if (count == 0){ + return (Uint256(1, 0),); + } + let (x) = _repeated_multiplication256(op, count - 1); + let (res) = warp_mul_signed256(op, x); + return (res,); +} +func warp_exp_signed256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : felt) -> (res : Uint256){ + if (rhs == 0){ + return (Uint256(1, 0),); + } + if (lhs.high == 0){ + if (lhs.low * (lhs.low - 1) == 0){ + return (lhs,); + } + } +if ((lhs.low - 0xffffffffffffffffffffffffffffffff) == 0 and (lhs.high - 0xffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (Uint256(1 + is_odd * 0xfffffffffffffffffffffffffffffffe, is_odd * 0xffffffffffffffffffffffffffffffff),); +} + let (res) = _repeated_multiplication256(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : Uint256, count : Uint256) -> (res : Uint256){ + if (count.low == 0 and count.high == 0){ + return (Uint256(1, 0),); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_256(op, decr); + let (res) = warp_mul_signed256(op, x); + return (res,); +} +func warp_exp_wide_signed256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + if (rhs.high == 0 and rhs.low == 0){ + return (Uint256(1, 0),); + } + if (lhs.high == 0 and lhs.low * (lhs.low - 1) == 0){ + return (lhs,); + } +if ((lhs.low - 0xffffffffffffffffffffffffffffffff) == 0 and (lhs.high - 0xffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (Uint256(1 + is_odd * 0xfffffffffffffffffffffffffffffffe, is_odd * 0xffffffffffffffffffffffffffffffff),); +} + let (res) = _repeated_multiplication_256_256(lhs, rhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/exp_signed_unsafe.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/exp_signed_unsafe.cairo new file mode 100644 index 000000000..6a571484c --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/exp_signed_unsafe.cairo @@ -0,0 +1,1758 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_sub +from warplib.maths.mul_signed_unsafe import warp_mul_signed_unsafe8, warp_mul_signed_unsafe16, warp_mul_signed_unsafe24, warp_mul_signed_unsafe32, warp_mul_signed_unsafe40, warp_mul_signed_unsafe48, warp_mul_signed_unsafe56, warp_mul_signed_unsafe64, warp_mul_signed_unsafe72, warp_mul_signed_unsafe80, warp_mul_signed_unsafe88, warp_mul_signed_unsafe96, warp_mul_signed_unsafe104, warp_mul_signed_unsafe112, warp_mul_signed_unsafe120, warp_mul_signed_unsafe128, warp_mul_signed_unsafe136, warp_mul_signed_unsafe144, warp_mul_signed_unsafe152, warp_mul_signed_unsafe160, warp_mul_signed_unsafe168, warp_mul_signed_unsafe176, warp_mul_signed_unsafe184, warp_mul_signed_unsafe192, warp_mul_signed_unsafe200, warp_mul_signed_unsafe208, warp_mul_signed_unsafe216, warp_mul_signed_unsafe224, warp_mul_signed_unsafe232, warp_mul_signed_unsafe240, warp_mul_signed_unsafe248, warp_mul_signed_unsafe256 + +func _repeated_multiplication8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication8(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe8(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xe,); +} + let (res) = _repeated_multiplication8(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_8(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe8(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xe,); +} + let (res) = _repeated_multiplication_256_8(lhs, rhs); + return (res,); +} +func _repeated_multiplication16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication16(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe16(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfe,); +} + let (res) = _repeated_multiplication16(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_16(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe16(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfe,); +} + let (res) = _repeated_multiplication_256_16(lhs, rhs); + return (res,); +} +func _repeated_multiplication24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication24(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe24(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffe,); +} + let (res) = _repeated_multiplication24(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_24(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe24(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffe,); +} + let (res) = _repeated_multiplication_256_24(lhs, rhs); + return (res,); +} +func _repeated_multiplication32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication32(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe32(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffe,); +} + let (res) = _repeated_multiplication32(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_32(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe32(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffe,); +} + let (res) = _repeated_multiplication_256_32(lhs, rhs); + return (res,); +} +func _repeated_multiplication40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication40(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe40(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffe,); +} + let (res) = _repeated_multiplication40(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_40(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe40(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffe,); +} + let (res) = _repeated_multiplication_256_40(lhs, rhs); + return (res,); +} +func _repeated_multiplication48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication48(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe48(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffe,); +} + let (res) = _repeated_multiplication48(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_48(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe48(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffe,); +} + let (res) = _repeated_multiplication_256_48(lhs, rhs); + return (res,); +} +func _repeated_multiplication56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication56(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe56(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffe,); +} + let (res) = _repeated_multiplication56(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_56(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe56(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffe,); +} + let (res) = _repeated_multiplication_256_56(lhs, rhs); + return (res,); +} +func _repeated_multiplication64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication64(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe64(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffe,); +} + let (res) = _repeated_multiplication64(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_64(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe64(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffe,); +} + let (res) = _repeated_multiplication_256_64(lhs, rhs); + return (res,); +} +func _repeated_multiplication72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication72(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe72(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffe,); +} + let (res) = _repeated_multiplication72(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_72(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe72(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffe,); +} + let (res) = _repeated_multiplication_256_72(lhs, rhs); + return (res,); +} +func _repeated_multiplication80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication80(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe80(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffe,); +} + let (res) = _repeated_multiplication80(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_80(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe80(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffe,); +} + let (res) = _repeated_multiplication_256_80(lhs, rhs); + return (res,); +} +func _repeated_multiplication88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication88(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe88(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffe,); +} + let (res) = _repeated_multiplication88(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_88(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe88(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffe,); +} + let (res) = _repeated_multiplication_256_88(lhs, rhs); + return (res,); +} +func _repeated_multiplication96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication96(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe96(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffe,); +} + let (res) = _repeated_multiplication96(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_96(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe96(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffe,); +} + let (res) = _repeated_multiplication_256_96(lhs, rhs); + return (res,); +} +func _repeated_multiplication104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication104(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe104(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffe,); +} + let (res) = _repeated_multiplication104(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_104(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe104(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffe,); +} + let (res) = _repeated_multiplication_256_104(lhs, rhs); + return (res,); +} +func _repeated_multiplication112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication112(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe112(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffe,); +} + let (res) = _repeated_multiplication112(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_112(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe112(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffe,); +} + let (res) = _repeated_multiplication_256_112(lhs, rhs); + return (res,); +} +func _repeated_multiplication120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication120(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe120(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffe,); +} + let (res) = _repeated_multiplication120(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_120(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe120(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_120(lhs, rhs); + return (res,); +} +func _repeated_multiplication128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication128(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe128(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffe,); +} + let (res) = _repeated_multiplication128(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_128(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe128(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_128(lhs, rhs); + return (res,); +} +func _repeated_multiplication136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication136(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe136(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffe,); +} + let (res) = _repeated_multiplication136(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_136(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe136(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_136(lhs, rhs); + return (res,); +} +func _repeated_multiplication144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication144(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe144(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffe,); +} + let (res) = _repeated_multiplication144(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_144(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe144(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_144(lhs, rhs); + return (res,); +} +func _repeated_multiplication152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication152(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe152(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffe,); +} + let (res) = _repeated_multiplication152(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_152(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe152(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_152(lhs, rhs); + return (res,); +} +func _repeated_multiplication160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication160(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe160(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffe,); +} + let (res) = _repeated_multiplication160(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_160(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe160(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_160(lhs, rhs); + return (res,); +} +func _repeated_multiplication168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication168(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe168(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication168(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_168(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe168(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_168(lhs, rhs); + return (res,); +} +func _repeated_multiplication176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication176(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe176(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication176(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_176(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe176(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_176(lhs, rhs); + return (res,); +} +func _repeated_multiplication184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication184(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe184(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication184(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_184(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe184(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_184(lhs, rhs); + return (res,); +} +func _repeated_multiplication192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication192(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe192(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication192(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_192(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe192(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_192(lhs, rhs); + return (res,); +} +func _repeated_multiplication200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication200(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe200(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication200(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_200(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe200(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_200(lhs, rhs); + return (res,); +} +func _repeated_multiplication208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication208(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe208(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication208(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_208(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe208(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_208(lhs, rhs); + return (res,); +} +func _repeated_multiplication216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication216(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe216(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication216(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_216(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe216(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_216(lhs, rhs); + return (res,); +} +func _repeated_multiplication224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication224(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe224(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication224(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_224(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe224(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_224(lhs, rhs); + return (res,); +} +func _repeated_multiplication232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication232(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe232(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication232(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_232(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe232(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_232(lhs, rhs); + return (res,); +} +func _repeated_multiplication240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication240(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe240(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication240(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_240(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe240(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_240(lhs, rhs); + return (res,); +} +func _repeated_multiplication248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication248(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe248(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication248(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_248(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe248(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_248(lhs, rhs); + return (res,); +} +func _repeated_multiplication256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : Uint256, count : felt) -> (res : Uint256){ + if (count == 0){ + return (Uint256(1, 0),); + } + let (x) = _repeated_multiplication256(op, count - 1); + let (res) = warp_mul_signed_unsafe256(op, x); + return (res,); +} +func warp_exp_signed_unsafe256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : felt) -> (res : Uint256){ + if (rhs == 0){ + return (Uint256(1, 0),); + } + if (lhs.high == 0){ + if (lhs.low * (lhs.low - 1) == 0){ + return (lhs,); + } + } +if ((lhs.low - 0xffffffffffffffffffffffffffffffff) == 0 and (lhs.high - 0xffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (Uint256(1 + is_odd * 0xfffffffffffffffffffffffffffffffe, is_odd * 0xffffffffffffffffffffffffffffffff),); +} + let (res) = _repeated_multiplication256(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : Uint256, count : Uint256) -> (res : Uint256){ + if (count.low == 0 and count.high == 0){ + return (Uint256(1, 0),); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_256(op, decr); + let (res) = warp_mul_signed_unsafe256(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + if (rhs.high == 0 and rhs.low == 0){ + return (Uint256(1, 0),); + } + if (lhs.high == 0 and lhs.low * (lhs.low - 1) == 0){ + return (lhs,); + } +if ((lhs.low - 0xffffffffffffffffffffffffffffffff) == 0 and (lhs.high - 0xffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (Uint256(1 + is_odd * 0xfffffffffffffffffffffffffffffffe, is_odd * 0xffffffffffffffffffffffffffffffff),); +} + let (res) = _repeated_multiplication_256_256(lhs, rhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/exp_unsafe.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/exp_unsafe.cairo new file mode 100644 index 000000000..e9c50fc66 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/exp_unsafe.cairo @@ -0,0 +1,1502 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_sub +from warplib.maths.mul_unsafe import warp_mul_unsafe8, warp_mul_unsafe16, warp_mul_unsafe24, warp_mul_unsafe32, warp_mul_unsafe40, warp_mul_unsafe48, warp_mul_unsafe56, warp_mul_unsafe64, warp_mul_unsafe72, warp_mul_unsafe80, warp_mul_unsafe88, warp_mul_unsafe96, warp_mul_unsafe104, warp_mul_unsafe112, warp_mul_unsafe120, warp_mul_unsafe128, warp_mul_unsafe136, warp_mul_unsafe144, warp_mul_unsafe152, warp_mul_unsafe160, warp_mul_unsafe168, warp_mul_unsafe176, warp_mul_unsafe184, warp_mul_unsafe192, warp_mul_unsafe200, warp_mul_unsafe208, warp_mul_unsafe216, warp_mul_unsafe224, warp_mul_unsafe232, warp_mul_unsafe240, warp_mul_unsafe248, warp_mul_unsafe256 + +func _repeated_multiplication8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication8(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe8(op, x); + return (res,); + } +} +func warp_exp_unsafe8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication8(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_8(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe8(op, x); + return (res,); +} +func warp_exp_wide_unsafe8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_8(lhs, rhs); + return (res,); +} +func _repeated_multiplication16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication16(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe16(op, x); + return (res,); + } +} +func warp_exp_unsafe16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication16(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_16(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe16(op, x); + return (res,); +} +func warp_exp_wide_unsafe16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_16(lhs, rhs); + return (res,); +} +func _repeated_multiplication24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication24(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe24(op, x); + return (res,); + } +} +func warp_exp_unsafe24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication24(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_24(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe24(op, x); + return (res,); +} +func warp_exp_wide_unsafe24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_24(lhs, rhs); + return (res,); +} +func _repeated_multiplication32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication32(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe32(op, x); + return (res,); + } +} +func warp_exp_unsafe32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication32(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_32(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe32(op, x); + return (res,); +} +func warp_exp_wide_unsafe32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_32(lhs, rhs); + return (res,); +} +func _repeated_multiplication40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication40(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe40(op, x); + return (res,); + } +} +func warp_exp_unsafe40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication40(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_40(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe40(op, x); + return (res,); +} +func warp_exp_wide_unsafe40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_40(lhs, rhs); + return (res,); +} +func _repeated_multiplication48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication48(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe48(op, x); + return (res,); + } +} +func warp_exp_unsafe48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication48(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_48(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe48(op, x); + return (res,); +} +func warp_exp_wide_unsafe48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_48(lhs, rhs); + return (res,); +} +func _repeated_multiplication56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication56(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe56(op, x); + return (res,); + } +} +func warp_exp_unsafe56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication56(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_56(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe56(op, x); + return (res,); +} +func warp_exp_wide_unsafe56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_56(lhs, rhs); + return (res,); +} +func _repeated_multiplication64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication64(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe64(op, x); + return (res,); + } +} +func warp_exp_unsafe64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication64(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_64(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe64(op, x); + return (res,); +} +func warp_exp_wide_unsafe64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_64(lhs, rhs); + return (res,); +} +func _repeated_multiplication72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication72(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe72(op, x); + return (res,); + } +} +func warp_exp_unsafe72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication72(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_72(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe72(op, x); + return (res,); +} +func warp_exp_wide_unsafe72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_72(lhs, rhs); + return (res,); +} +func _repeated_multiplication80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication80(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe80(op, x); + return (res,); + } +} +func warp_exp_unsafe80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication80(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_80(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe80(op, x); + return (res,); +} +func warp_exp_wide_unsafe80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_80(lhs, rhs); + return (res,); +} +func _repeated_multiplication88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication88(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe88(op, x); + return (res,); + } +} +func warp_exp_unsafe88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication88(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_88(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe88(op, x); + return (res,); +} +func warp_exp_wide_unsafe88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_88(lhs, rhs); + return (res,); +} +func _repeated_multiplication96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication96(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe96(op, x); + return (res,); + } +} +func warp_exp_unsafe96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication96(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_96(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe96(op, x); + return (res,); +} +func warp_exp_wide_unsafe96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_96(lhs, rhs); + return (res,); +} +func _repeated_multiplication104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication104(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe104(op, x); + return (res,); + } +} +func warp_exp_unsafe104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication104(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_104(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe104(op, x); + return (res,); +} +func warp_exp_wide_unsafe104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_104(lhs, rhs); + return (res,); +} +func _repeated_multiplication112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication112(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe112(op, x); + return (res,); + } +} +func warp_exp_unsafe112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication112(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_112(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe112(op, x); + return (res,); +} +func warp_exp_wide_unsafe112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_112(lhs, rhs); + return (res,); +} +func _repeated_multiplication120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication120(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe120(op, x); + return (res,); + } +} +func warp_exp_unsafe120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication120(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_120(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe120(op, x); + return (res,); +} +func warp_exp_wide_unsafe120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_120(lhs, rhs); + return (res,); +} +func _repeated_multiplication128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication128(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe128(op, x); + return (res,); + } +} +func warp_exp_unsafe128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication128(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_128(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe128(op, x); + return (res,); +} +func warp_exp_wide_unsafe128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_128(lhs, rhs); + return (res,); +} +func _repeated_multiplication136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication136(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe136(op, x); + return (res,); + } +} +func warp_exp_unsafe136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication136(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_136(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe136(op, x); + return (res,); +} +func warp_exp_wide_unsafe136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_136(lhs, rhs); + return (res,); +} +func _repeated_multiplication144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication144(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe144(op, x); + return (res,); + } +} +func warp_exp_unsafe144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication144(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_144(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe144(op, x); + return (res,); +} +func warp_exp_wide_unsafe144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_144(lhs, rhs); + return (res,); +} +func _repeated_multiplication152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication152(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe152(op, x); + return (res,); + } +} +func warp_exp_unsafe152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication152(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_152(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe152(op, x); + return (res,); +} +func warp_exp_wide_unsafe152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_152(lhs, rhs); + return (res,); +} +func _repeated_multiplication160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication160(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe160(op, x); + return (res,); + } +} +func warp_exp_unsafe160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication160(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_160(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe160(op, x); + return (res,); +} +func warp_exp_wide_unsafe160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_160(lhs, rhs); + return (res,); +} +func _repeated_multiplication168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication168(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe168(op, x); + return (res,); + } +} +func warp_exp_unsafe168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication168(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_168(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe168(op, x); + return (res,); +} +func warp_exp_wide_unsafe168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_168(lhs, rhs); + return (res,); +} +func _repeated_multiplication176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication176(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe176(op, x); + return (res,); + } +} +func warp_exp_unsafe176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication176(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_176(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe176(op, x); + return (res,); +} +func warp_exp_wide_unsafe176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_176(lhs, rhs); + return (res,); +} +func _repeated_multiplication184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication184(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe184(op, x); + return (res,); + } +} +func warp_exp_unsafe184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication184(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_184(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe184(op, x); + return (res,); +} +func warp_exp_wide_unsafe184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_184(lhs, rhs); + return (res,); +} +func _repeated_multiplication192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication192(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe192(op, x); + return (res,); + } +} +func warp_exp_unsafe192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication192(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_192(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe192(op, x); + return (res,); +} +func warp_exp_wide_unsafe192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_192(lhs, rhs); + return (res,); +} +func _repeated_multiplication200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication200(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe200(op, x); + return (res,); + } +} +func warp_exp_unsafe200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication200(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_200(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe200(op, x); + return (res,); +} +func warp_exp_wide_unsafe200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_200(lhs, rhs); + return (res,); +} +func _repeated_multiplication208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication208(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe208(op, x); + return (res,); + } +} +func warp_exp_unsafe208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication208(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_208(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe208(op, x); + return (res,); +} +func warp_exp_wide_unsafe208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_208(lhs, rhs); + return (res,); +} +func _repeated_multiplication216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication216(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe216(op, x); + return (res,); + } +} +func warp_exp_unsafe216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication216(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_216(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe216(op, x); + return (res,); +} +func warp_exp_wide_unsafe216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_216(lhs, rhs); + return (res,); +} +func _repeated_multiplication224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication224(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe224(op, x); + return (res,); + } +} +func warp_exp_unsafe224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication224(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_224(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe224(op, x); + return (res,); +} +func warp_exp_wide_unsafe224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_224(lhs, rhs); + return (res,); +} +func _repeated_multiplication232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication232(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe232(op, x); + return (res,); + } +} +func warp_exp_unsafe232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication232(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_232(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe232(op, x); + return (res,); +} +func warp_exp_wide_unsafe232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_232(lhs, rhs); + return (res,); +} +func _repeated_multiplication240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication240(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe240(op, x); + return (res,); + } +} +func warp_exp_unsafe240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication240(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_240(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe240(op, x); + return (res,); +} +func warp_exp_wide_unsafe240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_240(lhs, rhs); + return (res,); +} +func _repeated_multiplication248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication248(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe248(op, x); + return (res,); + } +} +func warp_exp_unsafe248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication248(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_248(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe248(op, x); + return (res,); +} +func warp_exp_wide_unsafe248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_248(lhs, rhs); + return (res,); +} +func _repeated_multiplication256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : Uint256, count : felt) -> (res : Uint256){ + if (count == 0){ + return (Uint256(1, 0),); + } + let (x) = _repeated_multiplication256(op, count - 1); + let (res) = warp_mul_unsafe256(op, x); + return (res,); +} +func warp_exp_unsafe256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : felt) -> (res : Uint256){ + if (rhs == 0){ + return (Uint256(1, 0),); + } + if (lhs.high == 0){ + if (lhs.low * (lhs.low - 1) == 0){ + return (lhs,); + } + } + let (res) = _repeated_multiplication256(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : Uint256, count : Uint256) -> (res : Uint256){ + if (count.low == 0 and count.high == 0){ + return (Uint256(1, 0),); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_256(op, decr); + let (res) = warp_mul_unsafe256(op, x); + return (res,); +} +func warp_exp_wide_unsafe256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + if (rhs.high == 0 and rhs.low == 0){ + return (Uint256(1, 0),); + } + if (lhs.high == 0 and lhs.low * (lhs.low - 1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_256(lhs, rhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/external_input_check_address.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/external_input_check_address.cairo new file mode 100644 index 000000000..f117887ac --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/external_input_check_address.cairo @@ -0,0 +1,7 @@ + +fn warp_external_input_check_address(x: felt) { + // The StarkNet address upper bound is 2**251 - 256, in max is stored its hex representation + let max: felt = 0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00; + + assert( x <= max, 'StarkNet address out-of-bounds'); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/external_input_check_bool.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/external_input_check_bool.cairo new file mode 100644 index 000000000..df6877796 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/external_input_check_bool.cairo @@ -0,0 +1,9 @@ +from starkware.cairo.common.math_cmp import is_le_felt + +func warp_external_input_check_bool{range_check_ptr}(x: felt) { + with_attr error_message( + "Error: value out-of-bounds. Boolean values passed to must be in range (0, 1].") { + assert x * (x - 1) = 0; + } + return (); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/external_input_check_ints.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/external_input_check_ints.cairo new file mode 100644 index 000000000..25cc30612 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/external_input_check_ints.cairo @@ -0,0 +1,160 @@ +//AUTO-GENERATED + + +fn warp_external_input_check_int8(x : felt){ + let max: felt = 0xff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int16(x : felt){ + let max: felt = 0xffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int24(x : felt){ + let max: felt = 0xffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int32(x : felt){ + let max: felt = 0xffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int40(x : felt){ + let max: felt = 0xffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int48(x : felt){ + let max: felt = 0xffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int56(x : felt){ + let max: felt = 0xffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int64(x : felt){ + let max: felt = 0xffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int72(x : felt){ + let max: felt = 0xffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int80(x : felt){ + let max: felt = 0xffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int88(x : felt){ + let max: felt = 0xffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int96(x : felt){ + let max: felt = 0xffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int104(x : felt){ + let max: felt = 0xffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int112(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int120(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int128(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int136(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int144(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int152(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int160(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int168(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int176(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int184(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int192(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int200(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int208(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int216(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int224(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int232(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int240(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int248(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int256(x : u256){} + diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/ge.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/ge.cairo new file mode 100644 index 000000000..123e256d1 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/ge.cairo @@ -0,0 +1,8 @@ + +fn warp_ge(lhs: felt, rhs: felt) -> bool { + return lhs >= rhs; +} + +fn warp_ge256(op1: u256, op2: u256) -> bool { + return op1 >= op2; +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/ge_signed.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/ge_signed.cairo new file mode 100644 index 000000000..e6dc6e7ea --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/ge_signed.cairo @@ -0,0 +1,165 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_signed_le +from warplib.maths.lt_signed import warp_le_signed8, warp_le_signed16, warp_le_signed24, warp_le_signed32, warp_le_signed40, warp_le_signed48, warp_le_signed56, warp_le_signed64, warp_le_signed72, warp_le_signed80, warp_le_signed88, warp_le_signed96, warp_le_signed104, warp_le_signed112, warp_le_signed120, warp_le_signed128, warp_le_signed136, warp_le_signed144, warp_le_signed152, warp_le_signed160, warp_le_signed168, warp_le_signed176, warp_le_signed184, warp_le_signed192, warp_le_signed200, warp_le_signed208, warp_le_signed216, warp_le_signed224, warp_le_signed232, warp_le_signed240, warp_le_signed248 + +func warp_ge_signed8{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed8(rhs, lhs); + return (res,); +} +func warp_ge_signed16{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed16(rhs, lhs); + return (res,); +} +func warp_ge_signed24{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed24(rhs, lhs); + return (res,); +} +func warp_ge_signed32{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed32(rhs, lhs); + return (res,); +} +func warp_ge_signed40{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed40(rhs, lhs); + return (res,); +} +func warp_ge_signed48{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed48(rhs, lhs); + return (res,); +} +func warp_ge_signed56{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed56(rhs, lhs); + return (res,); +} +func warp_ge_signed64{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed64(rhs, lhs); + return (res,); +} +func warp_ge_signed72{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed72(rhs, lhs); + return (res,); +} +func warp_ge_signed80{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed80(rhs, lhs); + return (res,); +} +func warp_ge_signed88{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed88(rhs, lhs); + return (res,); +} +func warp_ge_signed96{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed96(rhs, lhs); + return (res,); +} +func warp_ge_signed104{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed104(rhs, lhs); + return (res,); +} +func warp_ge_signed112{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed112(rhs, lhs); + return (res,); +} +func warp_ge_signed120{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed120(rhs, lhs); + return (res,); +} +func warp_ge_signed128{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed128(rhs, lhs); + return (res,); +} +func warp_ge_signed136{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed136(rhs, lhs); + return (res,); +} +func warp_ge_signed144{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed144(rhs, lhs); + return (res,); +} +func warp_ge_signed152{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed152(rhs, lhs); + return (res,); +} +func warp_ge_signed160{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed160(rhs, lhs); + return (res,); +} +func warp_ge_signed168{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed168(rhs, lhs); + return (res,); +} +func warp_ge_signed176{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed176(rhs, lhs); + return (res,); +} +func warp_ge_signed184{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed184(rhs, lhs); + return (res,); +} +func warp_ge_signed192{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed192(rhs, lhs); + return (res,); +} +func warp_ge_signed200{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed200(rhs, lhs); + return (res,); +} +func warp_ge_signed208{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed208(rhs, lhs); + return (res,); +} +func warp_ge_signed216{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed216(rhs, lhs); + return (res,); +} +func warp_ge_signed224{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed224(rhs, lhs); + return (res,); +} +func warp_ge_signed232{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed232(rhs, lhs); + return (res,); +} +func warp_ge_signed240{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed240(rhs, lhs); + return (res,); +} +func warp_ge_signed248{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed248(rhs, lhs); + return (res,); +} +func warp_ge_signed256{range_check_ptr}(lhs : Uint256, rhs : Uint256) -> (res : felt){ + let (res) = uint256_signed_le(rhs, lhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/gt.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/gt.cairo new file mode 100644 index 000000000..7ebcd2a60 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/gt.cairo @@ -0,0 +1,15 @@ +from starkware.cairo.common.math_cmp import is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_le + +func warp_gt{range_check_ptr}(lhs: felt, rhs: felt) -> (res: felt) { + if (lhs == rhs) { + return (0,); + } + let res = is_le_felt(rhs, lhs); + return (res,); +} + +func warp_gt256{range_check_ptr}(lhs: Uint256, rhs: Uint256) -> (res: felt) { + let (le) = uint256_le(lhs, rhs); + return (1 - le,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/gt_signed.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/gt_signed.cairo new file mode 100644 index 000000000..e1a487e3d --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/gt_signed.cairo @@ -0,0 +1,165 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_signed_lt +from warplib.maths.lt_signed import warp_lt_signed8, warp_lt_signed16, warp_lt_signed24, warp_lt_signed32, warp_lt_signed40, warp_lt_signed48, warp_lt_signed56, warp_lt_signed64, warp_lt_signed72, warp_lt_signed80, warp_lt_signed88, warp_lt_signed96, warp_lt_signed104, warp_lt_signed112, warp_lt_signed120, warp_lt_signed128, warp_lt_signed136, warp_lt_signed144, warp_lt_signed152, warp_lt_signed160, warp_lt_signed168, warp_lt_signed176, warp_lt_signed184, warp_lt_signed192, warp_lt_signed200, warp_lt_signed208, warp_lt_signed216, warp_lt_signed224, warp_lt_signed232, warp_lt_signed240, warp_lt_signed248 + +func warp_gt_signed8{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed8(rhs, lhs); + return (res,); +} +func warp_gt_signed16{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed16(rhs, lhs); + return (res,); +} +func warp_gt_signed24{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed24(rhs, lhs); + return (res,); +} +func warp_gt_signed32{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed32(rhs, lhs); + return (res,); +} +func warp_gt_signed40{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed40(rhs, lhs); + return (res,); +} +func warp_gt_signed48{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed48(rhs, lhs); + return (res,); +} +func warp_gt_signed56{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed56(rhs, lhs); + return (res,); +} +func warp_gt_signed64{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed64(rhs, lhs); + return (res,); +} +func warp_gt_signed72{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed72(rhs, lhs); + return (res,); +} +func warp_gt_signed80{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed80(rhs, lhs); + return (res,); +} +func warp_gt_signed88{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed88(rhs, lhs); + return (res,); +} +func warp_gt_signed96{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed96(rhs, lhs); + return (res,); +} +func warp_gt_signed104{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed104(rhs, lhs); + return (res,); +} +func warp_gt_signed112{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed112(rhs, lhs); + return (res,); +} +func warp_gt_signed120{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed120(rhs, lhs); + return (res,); +} +func warp_gt_signed128{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed128(rhs, lhs); + return (res,); +} +func warp_gt_signed136{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed136(rhs, lhs); + return (res,); +} +func warp_gt_signed144{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed144(rhs, lhs); + return (res,); +} +func warp_gt_signed152{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed152(rhs, lhs); + return (res,); +} +func warp_gt_signed160{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed160(rhs, lhs); + return (res,); +} +func warp_gt_signed168{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed168(rhs, lhs); + return (res,); +} +func warp_gt_signed176{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed176(rhs, lhs); + return (res,); +} +func warp_gt_signed184{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed184(rhs, lhs); + return (res,); +} +func warp_gt_signed192{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed192(rhs, lhs); + return (res,); +} +func warp_gt_signed200{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed200(rhs, lhs); + return (res,); +} +func warp_gt_signed208{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed208(rhs, lhs); + return (res,); +} +func warp_gt_signed216{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed216(rhs, lhs); + return (res,); +} +func warp_gt_signed224{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed224(rhs, lhs); + return (res,); +} +func warp_gt_signed232{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed232(rhs, lhs); + return (res,); +} +func warp_gt_signed240{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed240(rhs, lhs); + return (res,); +} +func warp_gt_signed248{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed248(rhs, lhs); + return (res,); +} +func warp_gt_signed256{range_check_ptr}(lhs : Uint256, rhs : Uint256) -> (res : felt){ + let (res) = uint256_signed_lt(rhs, lhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/int_conversions.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/int_conversions.cairo new file mode 100644 index 000000000..c24c95fcb --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/int_conversions.cairo @@ -0,0 +1,6087 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.math import split_felt +from starkware.cairo.common.uint256 import Uint256, uint256_add + + +func warp_int8_to_int16{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff00,); + } +} +func warp_int8_to_int24{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff00,); + } +} +func warp_int8_to_int32{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff00,); + } +} +func warp_int8_to_int40{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff00,); + } +} +func warp_int8_to_int48{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff00,); + } +} +func warp_int8_to_int56{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff00,); + } +} +func warp_int8_to_int64{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff00,); + } +} +func warp_int8_to_int72{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff00,); + } +} +func warp_int8_to_int80{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff00,); + } +} +func warp_int8_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff00,); + } +} +func warp_int8_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff00,); + } +} +func warp_int8_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffffffffffffffffffffffff00, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int16_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} + +func warp_int16_to_int24{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff0000,); + } +} +func warp_int16_to_int32{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff0000,); + } +} +func warp_int16_to_int40{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff0000,); + } +} +func warp_int16_to_int48{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff0000,); + } +} +func warp_int16_to_int56{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff0000,); + } +} +func warp_int16_to_int64{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff0000,); + } +} +func warp_int16_to_int72{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff0000,); + } +} +func warp_int16_to_int80{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff0000,); + } +} +func warp_int16_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff0000,); + } +} +func warp_int16_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff0000,); + } +} +func warp_int16_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x8000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffffffffffffffffffffff0000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int24_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int24_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} + +func warp_int24_to_int32{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff000000,); + } +} +func warp_int24_to_int40{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff000000,); + } +} +func warp_int24_to_int48{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff000000,); + } +} +func warp_int24_to_int56{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff000000,); + } +} +func warp_int24_to_int64{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff000000,); + } +} +func warp_int24_to_int72{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff000000,); + } +} +func warp_int24_to_int80{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff000000,); + } +} +func warp_int24_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff000000,); + } +} +func warp_int24_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff000000,); + } +} +func warp_int24_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff000000,); + } +} +func warp_int24_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x800000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffffffffffffffffffff000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int32_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int32_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int32_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} + +func warp_int32_to_int40{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff00000000,); + } +} +func warp_int32_to_int48{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff00000000,); + } +} +func warp_int32_to_int56{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff00000000,); + } +} +func warp_int32_to_int64{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff00000000,); + } +} +func warp_int32_to_int72{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff00000000,); + } +} +func warp_int32_to_int80{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff00000000,); + } +} +func warp_int32_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff00000000,); + } +} +func warp_int32_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff00000000,); + } +} +func warp_int32_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff00000000,); + } +} +func warp_int32_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffffffffffffffffff00000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int40_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int40_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int40_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int40_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} + +func warp_int40_to_int48{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff0000000000,); + } +} +func warp_int40_to_int56{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff0000000000,); + } +} +func warp_int40_to_int64{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff0000000000,); + } +} +func warp_int40_to_int72{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff0000000000,); + } +} +func warp_int40_to_int80{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff0000000000,); + } +} +func warp_int40_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff0000000000,); + } +} +func warp_int40_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff0000000000,); + } +} +func warp_int40_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff0000000000,); + } +} +func warp_int40_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x8000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffffffffffffffff0000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int48_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int48_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int48_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int48_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int48_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} + +func warp_int48_to_int56{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff000000000000,); + } +} +func warp_int48_to_int64{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff000000000000,); + } +} +func warp_int48_to_int72{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff000000000000,); + } +} +func warp_int48_to_int80{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff000000000000,); + } +} +func warp_int48_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff000000000000,); + } +} +func warp_int48_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff000000000000,); + } +} +func warp_int48_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff000000000000,); + } +} +func warp_int48_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff000000000000,); + } +} +func warp_int48_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x800000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffffffffffffff000000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int56_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int56_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int56_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int56_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int56_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int56_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} + +func warp_int56_to_int64{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff00000000000000,); + } +} +func warp_int56_to_int72{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff00000000000000,); + } +} +func warp_int56_to_int80{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff00000000000000,); + } +} +func warp_int56_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff00000000000000,); + } +} +func warp_int56_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff00000000000000,); + } +} +func warp_int56_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff00000000000000,); + } +} +func warp_int56_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff00000000000000,); + } +} +func warp_int56_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffffffffffff00000000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int64_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int64_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int64_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int64_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int64_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int64_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int64_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} + +func warp_int64_to_int72{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff0000000000000000,); + } +} +func warp_int64_to_int80{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff0000000000000000,); + } +} +func warp_int64_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff0000000000000000,); + } +} +func warp_int64_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff0000000000000000,); + } +} +func warp_int64_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff0000000000000000,); + } +} +func warp_int64_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff0000000000000000,); + } +} +func warp_int64_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x8000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffffffffff0000000000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int72_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int72_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int72_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int72_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int72_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int72_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int72_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int72_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} + +func warp_int72_to_int80{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff000000000000000000,); + } +} +func warp_int72_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff000000000000000000,); + } +} +func warp_int72_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff000000000000000000,); + } +} +func warp_int72_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff000000000000000000,); + } +} +func warp_int72_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff000000000000000000,); + } +} +func warp_int72_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff000000000000000000,); + } +} +func warp_int72_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x800000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffffffff000000000000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int80_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int80_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int80_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int80_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int80_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int80_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int80_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int80_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int80_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} + +func warp_int80_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff00000000000000000000,); + } +} +func warp_int80_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff00000000000000000000,); + } +} +func warp_int80_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff00000000000000000000,); + } +} +func warp_int80_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff00000000000000000000,); + } +} +func warp_int80_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff00000000000000000000,); + } +} +func warp_int80_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffffff00000000000000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int88_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int88_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int88_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int88_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int88_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int88_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int88_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int88_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int88_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int88_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} + +func warp_int88_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff0000000000000000000000,); + } +} +func warp_int88_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff0000000000000000000000,); + } +} +func warp_int88_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff0000000000000000000000,); + } +} +func warp_int88_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff0000000000000000000000,); + } +} +func warp_int88_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffff0000000000000000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int96_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int96_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int96_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int96_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int96_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int96_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int96_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int96_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int96_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int96_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int96_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} + +func warp_int96_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff000000000000000000000000,); + } +} +func warp_int96_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff000000000000000000000000,); + } +} +func warp_int96_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff000000000000000000000000,); + } +} +func warp_int96_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff000000000000000000000000,); + } +} +func warp_int96_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffff000000000000000000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int104_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int104_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int104_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int104_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int104_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int104_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int104_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int104_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int104_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int104_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int104_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int104_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} + +func warp_int104_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff00000000000000000000000000,); + } +} +func warp_int104_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff00000000000000000000000000,); + } +} +func warp_int104_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff00000000000000000000000000,); + } +} +func warp_int104_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffff00000000000000000000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int112_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int112_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int112_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int112_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int112_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int112_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int112_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int112_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int112_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int112_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int112_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int112_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int112_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} + +func warp_int112_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff0000000000000000000000000000,); + } +} +func warp_int112_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff0000000000000000000000000000,); + } +} +func warp_int112_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffff0000000000000000000000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int120_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int120_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int120_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int120_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int120_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int120_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int120_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int120_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int120_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int120_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int120_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int120_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int120_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int120_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int120_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff000000000000000000000000000000,); + } +} +func warp_int120_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff000000000000000000000000000000,); + } +} +func warp_int120_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xff000000000000000000000000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int128_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int128_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int128_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int128_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int128_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int128_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int128_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int128_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int128_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int128_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int128_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int128_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int128_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int128_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int128_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int128_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff00000000000000000000000000000000,); + } +} +func warp_int128_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int136_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int136_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int136_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int136_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int136_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int136_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int136_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int136_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int136_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int136_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int136_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int136_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int136_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int136_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int136_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int136_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int136_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffffffffffffffffffffff00)); + return (res,); + } +} +func warp_int144_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int144_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int144_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int144_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int144_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int144_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int144_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int144_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int144_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int144_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int144_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int144_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int144_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int144_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int144_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int144_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int144_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int144_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffffffffffffffffffff0000)); + return (res,); + } +} +func warp_int152_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int152_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int152_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int152_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int152_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int152_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int152_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int152_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int152_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int152_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int152_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int152_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int152_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int152_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int152_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int152_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int152_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int152_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int152_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffffffffffffffffff000000)); + return (res,); + } +} +func warp_int160_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int160_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int160_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int160_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int160_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int160_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int160_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int160_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int160_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int160_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int160_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int160_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int160_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int160_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int160_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int160_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int160_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int160_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int160_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int160_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffffffffffffffff00000000)); + return (res,); + } +} +func warp_int168_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int168_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int168_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int168_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int168_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int168_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int168_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int168_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int168_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int168_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int168_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int168_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int168_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int168_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int168_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int168_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int168_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int168_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int168_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int168_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int168_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff000000000000000000000000000000000000000000,); + } +} +func warp_int168_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff000000000000000000000000000000000000000000,); + } +} +func warp_int168_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff000000000000000000000000000000000000000000,); + } +} +func warp_int168_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff000000000000000000000000000000000000000000,); + } +} +func warp_int168_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff000000000000000000000000000000000000000000,); + } +} +func warp_int168_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff000000000000000000000000000000000000000000,); + } +} +func warp_int168_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff000000000000000000000000000000000000000000,); + } +} +func warp_int168_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff000000000000000000000000000000000000000000,); + } +} +func warp_int168_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff000000000000000000000000000000000000000000,); + } +} +func warp_int168_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff000000000000000000000000000000000000000000,); + } +} +func warp_int168_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffffffffffffff0000000000)); + return (res,); + } +} +func warp_int176_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int176_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int176_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int176_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int176_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int176_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int176_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int176_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int176_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int176_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int176_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff00000000000000000000000000000000000000000000,); + } +} +func warp_int176_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff00000000000000000000000000000000000000000000,); + } +} +func warp_int176_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff00000000000000000000000000000000000000000000,); + } +} +func warp_int176_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff00000000000000000000000000000000000000000000,); + } +} +func warp_int176_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff00000000000000000000000000000000000000000000,); + } +} +func warp_int176_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff00000000000000000000000000000000000000000000,); + } +} +func warp_int176_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff00000000000000000000000000000000000000000000,); + } +} +func warp_int176_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff00000000000000000000000000000000000000000000,); + } +} +func warp_int176_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff00000000000000000000000000000000000000000000,); + } +} +func warp_int176_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffffffffffff000000000000)); + return (res,); + } +} +func warp_int184_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int184_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int184_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int184_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int184_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int184_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int184_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int184_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int184_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int184_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int184_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff0000000000000000000000000000000000000000000000,); + } +} +func warp_int184_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff0000000000000000000000000000000000000000000000,); + } +} +func warp_int184_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff0000000000000000000000000000000000000000000000,); + } +} +func warp_int184_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff0000000000000000000000000000000000000000000000,); + } +} +func warp_int184_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff0000000000000000000000000000000000000000000000,); + } +} +func warp_int184_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff0000000000000000000000000000000000000000000000,); + } +} +func warp_int184_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff0000000000000000000000000000000000000000000000,); + } +} +func warp_int184_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff0000000000000000000000000000000000000000000000,); + } +} +func warp_int184_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffffffffff00000000000000)); + return (res,); + } +} +func warp_int192_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int192_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int192_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int192_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int192_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int192_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int192_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int192_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int192_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int192_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int184{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int192_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff000000000000000000000000000000000000000000000000,); + } +} +func warp_int192_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff000000000000000000000000000000000000000000000000,); + } +} +func warp_int192_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff000000000000000000000000000000000000000000000000,); + } +} +func warp_int192_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff000000000000000000000000000000000000000000000000,); + } +} +func warp_int192_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff000000000000000000000000000000000000000000000000,); + } +} +func warp_int192_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff000000000000000000000000000000000000000000000000,); + } +} +func warp_int192_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff000000000000000000000000000000000000000000000000,); + } +} +func warp_int192_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffffffff0000000000000000)); + return (res,); + } +} +func warp_int200_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int200_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int200_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int200_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int200_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int200_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int200_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int200_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int200_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int200_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int184{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int192{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int200_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff00000000000000000000000000000000000000000000000000,); + } +} +func warp_int200_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff00000000000000000000000000000000000000000000000000,); + } +} +func warp_int200_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff00000000000000000000000000000000000000000000000000,); + } +} +func warp_int200_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff00000000000000000000000000000000000000000000000000,); + } +} +func warp_int200_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff00000000000000000000000000000000000000000000000000,); + } +} +func warp_int200_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff00000000000000000000000000000000000000000000000000,); + } +} +func warp_int200_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffffff000000000000000000)); + return (res,); + } +} +func warp_int208_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int208_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int208_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int208_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int208_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int208_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int208_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int208_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int208_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int208_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int184{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int192{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int200{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int208_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff0000000000000000000000000000000000000000000000000000,); + } +} +func warp_int208_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff0000000000000000000000000000000000000000000000000000,); + } +} +func warp_int208_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff0000000000000000000000000000000000000000000000000000,); + } +} +func warp_int208_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff0000000000000000000000000000000000000000000000000000,); + } +} +func warp_int208_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff0000000000000000000000000000000000000000000000000000,); + } +} +func warp_int208_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffff00000000000000000000)); + return (res,); + } +} +func warp_int216_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int216_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int216_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int216_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int216_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int216_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int216_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int216_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int216_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int216_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int184{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int192{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int200{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int208{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int216_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff000000000000000000000000000000000000000000000000000000,); + } +} +func warp_int216_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff000000000000000000000000000000000000000000000000000000,); + } +} +func warp_int216_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff000000000000000000000000000000000000000000000000000000,); + } +} +func warp_int216_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff000000000000000000000000000000000000000000000000000000,); + } +} +func warp_int216_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffff0000000000000000000000)); + return (res,); + } +} +func warp_int224_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int224_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int224_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int224_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int224_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int224_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int224_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int224_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int224_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int224_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int184{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int192{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int200{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int208{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int216{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int224_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff00000000000000000000000000000000000000000000000000000000,); + } +} +func warp_int224_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff00000000000000000000000000000000000000000000000000000000,); + } +} +func warp_int224_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff00000000000000000000000000000000000000000000000000000000,); + } +} +func warp_int224_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffff000000000000000000000000)); + return (res,); + } +} +func warp_int232_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int232_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int232_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int232_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int232_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int232_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int232_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int232_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int232_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int232_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int184{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int192{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int200{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int208{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int216{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int224{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int232_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff0000000000000000000000000000000000000000000000000000000000,); + } +} +func warp_int232_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff0000000000000000000000000000000000000000000000000000000000,); + } +} +func warp_int232_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffff00000000000000000000000000)); + return (res,); + } +} +func warp_int240_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int240_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int240_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int240_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int240_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int240_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int240_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int240_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int240_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int240_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int184{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int192{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int200{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int208{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int216{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int224{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int232{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int240_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff000000000000000000000000000000000000000000000000000000000000,); + } +} +func warp_int240_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffff0000000000000000000000000000)); + return (res,); + } +} +func warp_int248_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int248_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int248_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int248_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int248_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int248_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int248_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int248_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int248_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int248_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int184{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int192{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int200{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int208{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int216{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int224{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int232{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int240{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int248_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xff000000000000000000000000000000)); + return (res,); + } +} +func warp_int256_to_int8{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xff); + return (res,); +} +func warp_int256_to_int16{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffff); + return (res,); +} +func warp_int256_to_int24{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffff); + return (res,); +} +func warp_int256_to_int32{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffff); + return (res,); +} +func warp_int256_to_int40{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffff); + return (res,); +} +func warp_int256_to_int48{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffff); + return (res,); +} +func warp_int256_to_int56{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffffff); + return (res,); +} +func warp_int256_to_int64{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffffffff); + return (res,); +} +func warp_int256_to_int72{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffffffffff); + return (res,); +} +func warp_int256_to_int80{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffffffffffff); + return (res,); +} +func warp_int256_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int256_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int256_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int256_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int256_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int256_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int256_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffffffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffffffffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffffffffffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffffffffffffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffffffffffffffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffffffffffffffffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} + +func warp_uint256{range_check_ptr}(op : felt) -> (res : Uint256){ + let split = split_felt(op); + return (Uint256(low=split.low, high=split.high),); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/le.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/le.cairo new file mode 100644 index 000000000..ab09314f7 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/le.cairo @@ -0,0 +1,12 @@ +from starkware.cairo.common.math_cmp import is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_le + +func warp_le{range_check_ptr}(lhs: felt, rhs: felt) -> (res: felt) { + let res = is_le_felt(lhs, rhs); + return (res,); +} + +func warp_le256{range_check_ptr}(lhs: Uint256, rhs: Uint256) -> (result: felt) { + let (res) = uint256_le(lhs, rhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/le_signed.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/le_signed.cairo new file mode 100644 index 000000000..ca582e037 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/le_signed.cairo @@ -0,0 +1,909 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.math_cmp import is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_signed_le + +func warp_le_signed8{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed16{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x8000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x8000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed24{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x800000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x800000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed32{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed40{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x8000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x8000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed48{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x800000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x800000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed56{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed64{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x8000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x8000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed72{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x800000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x800000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed80{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed88{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed96{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed104{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed112{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed120{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed128{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed136{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed144{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed152{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed160{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed168{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed176{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed184{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed192{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed200{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed208{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed216{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed224{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed232{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed240{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed248{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed256{range_check_ptr}(lhs : Uint256, rhs : Uint256) -> (res : felt){ + let (res) = uint256_signed_le(lhs, rhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/lt.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/lt.cairo new file mode 100644 index 000000000..ce19c629f --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/lt.cairo @@ -0,0 +1,15 @@ +from starkware.cairo.common.math_cmp import is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_lt + +func warp_lt{range_check_ptr}(lhs: felt, rhs: felt) -> (res: felt) { + if (lhs == rhs) { + return (0,); + } + let res = is_le_felt(lhs, rhs); + return (res,); +} + +func warp_lt256{range_check_ptr}(lhs: Uint256, rhs: Uint256) -> (res: felt) { + let (res) = uint256_lt(lhs, rhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/lt_signed.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/lt_signed.cairo new file mode 100644 index 000000000..9738d4c46 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/lt_signed.cairo @@ -0,0 +1,258 @@ +//AUTO-GENERATED +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_signed_lt +from warplib.maths.utils import felt_to_uint256 +from warplib.maths.le_signed import warp_le_signed8, warp_le_signed16, warp_le_signed24, warp_le_signed32, warp_le_signed40, warp_le_signed48, warp_le_signed56, warp_le_signed64, warp_le_signed72, warp_le_signed80, warp_le_signed88, warp_le_signed96, warp_le_signed104, warp_le_signed112, warp_le_signed120, warp_le_signed128, warp_le_signed136, warp_le_signed144, warp_le_signed152, warp_le_signed160, warp_le_signed168, warp_le_signed176, warp_le_signed184, warp_le_signed192, warp_le_signed200, warp_le_signed208, warp_le_signed216, warp_le_signed224, warp_le_signed232, warp_le_signed240, warp_le_signed248 + +func warp_lt_signed8{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed8(lhs, rhs); + return (res,); +} +func warp_lt_signed16{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed16(lhs, rhs); + return (res,); +} +func warp_lt_signed24{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed24(lhs, rhs); + return (res,); +} +func warp_lt_signed32{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed32(lhs, rhs); + return (res,); +} +func warp_lt_signed40{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed40(lhs, rhs); + return (res,); +} +func warp_lt_signed48{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed48(lhs, rhs); + return (res,); +} +func warp_lt_signed56{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed56(lhs, rhs); + return (res,); +} +func warp_lt_signed64{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed64(lhs, rhs); + return (res,); +} +func warp_lt_signed72{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed72(lhs, rhs); + return (res,); +} +func warp_lt_signed80{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed80(lhs, rhs); + return (res,); +} +func warp_lt_signed88{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed88(lhs, rhs); + return (res,); +} +func warp_lt_signed96{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed96(lhs, rhs); + return (res,); +} +func warp_lt_signed104{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed104(lhs, rhs); + return (res,); +} +func warp_lt_signed112{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed112(lhs, rhs); + return (res,); +} +func warp_lt_signed120{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed120(lhs, rhs); + return (res,); +} +func warp_lt_signed128{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed128(lhs, rhs); + return (res,); +} +func warp_lt_signed136{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed136(lhs, rhs); + return (res,); +} +func warp_lt_signed144{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed144(lhs, rhs); + return (res,); +} +func warp_lt_signed152{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed152(lhs, rhs); + return (res,); +} +func warp_lt_signed160{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed160(lhs, rhs); + return (res,); +} +func warp_lt_signed168{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed168(lhs, rhs); + return (res,); +} +func warp_lt_signed176{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed176(lhs, rhs); + return (res,); +} +func warp_lt_signed184{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed184(lhs, rhs); + return (res,); +} +func warp_lt_signed192{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed192(lhs, rhs); + return (res,); +} +func warp_lt_signed200{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed200(lhs, rhs); + return (res,); +} +func warp_lt_signed208{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed208(lhs, rhs); + return (res,); +} +func warp_lt_signed216{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed216(lhs, rhs); + return (res,); +} +func warp_lt_signed224{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed224(lhs, rhs); + return (res,); +} +func warp_lt_signed232{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed232(lhs, rhs); + return (res,); +} +func warp_lt_signed240{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed240(lhs, rhs); + return (res,); +} +func warp_lt_signed248{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed248(lhs, rhs); + return (res,); +} +func warp_lt_signed256{range_check_ptr}(lhs : Uint256, rhs : Uint256) -> (res : felt){ + let (res) = uint256_signed_lt(lhs, rhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/mod.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/mod.cairo new file mode 100644 index 000000000..4c87b8b62 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/mod.cairo @@ -0,0 +1,28 @@ +from starkware.cairo.common.uint256 import Uint256, uint256_unsigned_div_rem +from warplib.maths.utils import felt_to_uint256 + +const SHIFT = 2 ** 128; + +func warp_mod{range_check_ptr}(lhs: felt, rhs: felt) -> (res: felt) { + if (rhs == 0) { + with_attr error_message("Modulo by zero error") { + assert 1 = 0; + } + } + let (lhs_256) = felt_to_uint256(lhs); + let (rhs_256) = felt_to_uint256(rhs); + let (_, res256) = uint256_unsigned_div_rem(lhs_256, rhs_256); + return (res256.low + SHIFT * res256.high,); +} + +func warp_mod256{range_check_ptr}(lhs: Uint256, rhs: Uint256) -> (res: Uint256) { + if (rhs.high == 0) { + if (rhs.low == 0) { + with_attr error_message("Modulo by zero error") { + assert 1 = 0; + } + } + } + let (_, res: Uint256) = uint256_unsigned_div_rem(lhs, rhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/mod_signed.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/mod_signed.cairo new file mode 100644 index 000000000..573a04383 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/mod_signed.cairo @@ -0,0 +1,419 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_signed_div_rem +from warplib.maths.utils import felt_to_uint256 +from warplib.maths.int_conversions import warp_int8_to_int256, warp_int16_to_int256, warp_int24_to_int256, warp_int32_to_int256, warp_int40_to_int256, warp_int48_to_int256, warp_int56_to_int256, warp_int64_to_int256, warp_int72_to_int256, warp_int80_to_int256, warp_int88_to_int256, warp_int96_to_int256, warp_int104_to_int256, warp_int112_to_int256, warp_int120_to_int256, warp_int128_to_int256, warp_int136_to_int256, warp_int144_to_int256, warp_int152_to_int256, warp_int160_to_int256, warp_int168_to_int256, warp_int176_to_int256, warp_int184_to_int256, warp_int192_to_int256, warp_int200_to_int256, warp_int208_to_int256, warp_int216_to_int256, warp_int224_to_int256, warp_int232_to_int256, warp_int240_to_int256, warp_int248_to_int256, warp_int256_to_int8, warp_int256_to_int16, warp_int256_to_int24, warp_int256_to_int32, warp_int256_to_int40, warp_int256_to_int48, warp_int256_to_int56, warp_int256_to_int64, warp_int256_to_int72, warp_int256_to_int80, warp_int256_to_int88, warp_int256_to_int96, warp_int256_to_int104, warp_int256_to_int112, warp_int256_to_int120, warp_int256_to_int128, warp_int256_to_int136, warp_int256_to_int144, warp_int256_to_int152, warp_int256_to_int160, warp_int256_to_int168, warp_int256_to_int176, warp_int256_to_int184, warp_int256_to_int192, warp_int256_to_int200, warp_int256_to_int208, warp_int256_to_int216, warp_int256_to_int224, warp_int256_to_int232, warp_int256_to_int240, warp_int256_to_int248 + +func warp_mod_signed8{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int8_to_int256(lhs); + let (rhs_256) = warp_int8_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int8(res256); + return (truncated,); +} +func warp_mod_signed16{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int16_to_int256(lhs); + let (rhs_256) = warp_int16_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int16(res256); + return (truncated,); +} +func warp_mod_signed24{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int24_to_int256(lhs); + let (rhs_256) = warp_int24_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int24(res256); + return (truncated,); +} +func warp_mod_signed32{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int32_to_int256(lhs); + let (rhs_256) = warp_int32_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int32(res256); + return (truncated,); +} +func warp_mod_signed40{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int40_to_int256(lhs); + let (rhs_256) = warp_int40_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int40(res256); + return (truncated,); +} +func warp_mod_signed48{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int48_to_int256(lhs); + let (rhs_256) = warp_int48_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int48(res256); + return (truncated,); +} +func warp_mod_signed56{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int56_to_int256(lhs); + let (rhs_256) = warp_int56_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int56(res256); + return (truncated,); +} +func warp_mod_signed64{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int64_to_int256(lhs); + let (rhs_256) = warp_int64_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int64(res256); + return (truncated,); +} +func warp_mod_signed72{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int72_to_int256(lhs); + let (rhs_256) = warp_int72_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int72(res256); + return (truncated,); +} +func warp_mod_signed80{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int80_to_int256(lhs); + let (rhs_256) = warp_int80_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int80(res256); + return (truncated,); +} +func warp_mod_signed88{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int88_to_int256(lhs); + let (rhs_256) = warp_int88_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int88(res256); + return (truncated,); +} +func warp_mod_signed96{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int96_to_int256(lhs); + let (rhs_256) = warp_int96_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int96(res256); + return (truncated,); +} +func warp_mod_signed104{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int104_to_int256(lhs); + let (rhs_256) = warp_int104_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int104(res256); + return (truncated,); +} +func warp_mod_signed112{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int112_to_int256(lhs); + let (rhs_256) = warp_int112_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int112(res256); + return (truncated,); +} +func warp_mod_signed120{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int120_to_int256(lhs); + let (rhs_256) = warp_int120_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int120(res256); + return (truncated,); +} +func warp_mod_signed128{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int128_to_int256(lhs); + let (rhs_256) = warp_int128_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int128(res256); + return (truncated,); +} +func warp_mod_signed136{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int136_to_int256(lhs); + let (rhs_256) = warp_int136_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int136(res256); + return (truncated,); +} +func warp_mod_signed144{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int144_to_int256(lhs); + let (rhs_256) = warp_int144_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int144(res256); + return (truncated,); +} +func warp_mod_signed152{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int152_to_int256(lhs); + let (rhs_256) = warp_int152_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int152(res256); + return (truncated,); +} +func warp_mod_signed160{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int160_to_int256(lhs); + let (rhs_256) = warp_int160_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int160(res256); + return (truncated,); +} +func warp_mod_signed168{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int168_to_int256(lhs); + let (rhs_256) = warp_int168_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int168(res256); + return (truncated,); +} +func warp_mod_signed176{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int176_to_int256(lhs); + let (rhs_256) = warp_int176_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int176(res256); + return (truncated,); +} +func warp_mod_signed184{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int184_to_int256(lhs); + let (rhs_256) = warp_int184_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int184(res256); + return (truncated,); +} +func warp_mod_signed192{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int192_to_int256(lhs); + let (rhs_256) = warp_int192_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int192(res256); + return (truncated,); +} +func warp_mod_signed200{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int200_to_int256(lhs); + let (rhs_256) = warp_int200_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int200(res256); + return (truncated,); +} +func warp_mod_signed208{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int208_to_int256(lhs); + let (rhs_256) = warp_int208_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int208(res256); + return (truncated,); +} +func warp_mod_signed216{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int216_to_int256(lhs); + let (rhs_256) = warp_int216_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int216(res256); + return (truncated,); +} +func warp_mod_signed224{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int224_to_int256(lhs); + let (rhs_256) = warp_int224_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int224(res256); + return (truncated,); +} +func warp_mod_signed232{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int232_to_int256(lhs); + let (rhs_256) = warp_int232_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int232(res256); + return (truncated,); +} +func warp_mod_signed240{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int240_to_int256(lhs); + let (rhs_256) = warp_int240_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int240(res256); + return (truncated,); +} +func warp_mod_signed248{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int248_to_int256(lhs); + let (rhs_256) = warp_int248_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int248(res256); + return (truncated,); +} +func warp_mod_signed256{range_check_ptr}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + if (rhs.high == 0 and rhs.low == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (_, res : Uint256) = uint256_signed_div_rem(lhs, rhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/mul.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/mul.cairo new file mode 100644 index 000000000..ec21748c9 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/mul.cairo @@ -0,0 +1,246 @@ +//AUTO-GENERATED +from starkware.cairo.common.uint256 import Uint256, uint256_mul +from starkware.cairo.common.math_cmp import is_le_felt +from warplib.maths.ge import warp_ge256 +from warplib.maths.utils import felt_to_uint256 + +func warp_mul8{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xff); + assert inRange = 1; + return (res,); +} +func warp_mul16{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffff); + assert inRange = 1; + return (res,); +} +func warp_mul24{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffff); + assert inRange = 1; + return (res,); +} +func warp_mul32{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul40{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul48{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul56{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul64{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul72{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul80{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffffffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul88{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffffffffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul96{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffffffffffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul104{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffffffffffffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul112{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffffffffffffffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul120{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffffffffffffffffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul128{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x1)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul136{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x100)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul144{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x10000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul152{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x1000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul160{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x100000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul168{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x10000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul176{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x1000000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul184{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x100000000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul192{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x10000000000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul200{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x1000000000000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul208{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x100000000000000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul216{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x10000000000000000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul224{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x1000000000000000000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul232{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x100000000000000000000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul240{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x10000000000000000000000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul248{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x1000000000000000000000000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul256{range_check_ptr}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + let (result : Uint256, overflow : Uint256) = uint256_mul(lhs, rhs); + assert overflow.low = 0; + assert overflow.high = 0; + return (result,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/mul_signed.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/mul_signed.cairo new file mode 100644 index 000000000..7869bbac3 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/mul_signed.cairo @@ -0,0 +1,1214 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.math_cmp import is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_mul, uint256_cond_neg, uint256_signed_nn, uint256_neg, uint256_le +from warplib.maths.utils import felt_to_uint256 +from warplib.maths.le import warp_le +from warplib.maths.mul import warp_mul8, warp_mul16, warp_mul24, warp_mul32, warp_mul40, warp_mul48, warp_mul56, warp_mul64, warp_mul72, warp_mul80, warp_mul88, warp_mul96, warp_mul104, warp_mul112, warp_mul120, warp_mul128, warp_mul136, warp_mul144, warp_mul152, warp_mul160, warp_mul168, warp_mul176, warp_mul184, warp_mul192, warp_mul200, warp_mul208, warp_mul216, warp_mul224, warp_mul232, warp_mul240, warp_mul248 +from warplib.maths.negate import warp_negate8, warp_negate16, warp_negate24, warp_negate32, warp_negate40, warp_negate48, warp_negate56, warp_negate64, warp_negate72, warp_negate80, warp_negate88, warp_negate96, warp_negate104, warp_negate112, warp_negate120, warp_negate128, warp_negate136, warp_negate144, warp_negate152, warp_negate160, warp_negate168, warp_negate176, warp_negate184, warp_negate192, warp_negate200, warp_negate208, warp_negate216, warp_negate224, warp_negate232, warp_negate240, warp_negate248 + +func warp_mul_signed8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80); + if (right_msb == 0){ + let (res) = warp_mul8(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate8(rhs); + let (res_abs) = warp_mul8(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80); + assert in_range = 1; + let (res) = warp_negate8(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80); + if (right_msb == 0){ + let (lhs_abs) = warp_negate8(lhs); + let (res_abs) = warp_mul8(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80); + assert in_range = 1; + let (res) = warp_negate8(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate8(lhs); + let (rhs_abs) = warp_negate8(rhs); + let (res) = warp_mul8(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x8000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x8000); + if (right_msb == 0){ + let (res) = warp_mul16(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x8000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate16(rhs); + let (res_abs) = warp_mul16(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x8000); + assert in_range = 1; + let (res) = warp_negate16(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x8000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate16(lhs); + let (res_abs) = warp_mul16(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x8000); + assert in_range = 1; + let (res) = warp_negate16(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate16(lhs); + let (rhs_abs) = warp_negate16(rhs); + let (res) = warp_mul16(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x8000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x800000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x800000); + if (right_msb == 0){ + let (res) = warp_mul24(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x800000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate24(rhs); + let (res_abs) = warp_mul24(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x800000); + assert in_range = 1; + let (res) = warp_negate24(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x800000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate24(lhs); + let (res_abs) = warp_mul24(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x800000); + assert in_range = 1; + let (res) = warp_negate24(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate24(lhs); + let (rhs_abs) = warp_negate24(rhs); + let (res) = warp_mul24(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x800000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80000000); + if (right_msb == 0){ + let (res) = warp_mul32(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate32(rhs); + let (res_abs) = warp_mul32(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80000000); + assert in_range = 1; + let (res) = warp_negate32(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate32(lhs); + let (res_abs) = warp_mul32(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80000000); + assert in_range = 1; + let (res) = warp_negate32(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate32(lhs); + let (rhs_abs) = warp_negate32(rhs); + let (res) = warp_mul32(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x8000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x8000000000); + if (right_msb == 0){ + let (res) = warp_mul40(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x8000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate40(rhs); + let (res_abs) = warp_mul40(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x8000000000); + assert in_range = 1; + let (res) = warp_negate40(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x8000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate40(lhs); + let (res_abs) = warp_mul40(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x8000000000); + assert in_range = 1; + let (res) = warp_negate40(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate40(lhs); + let (rhs_abs) = warp_negate40(rhs); + let (res) = warp_mul40(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x8000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x800000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x800000000000); + if (right_msb == 0){ + let (res) = warp_mul48(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x800000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate48(rhs); + let (res_abs) = warp_mul48(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x800000000000); + assert in_range = 1; + let (res) = warp_negate48(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x800000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate48(lhs); + let (res_abs) = warp_mul48(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x800000000000); + assert in_range = 1; + let (res) = warp_negate48(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate48(lhs); + let (rhs_abs) = warp_negate48(rhs); + let (res) = warp_mul48(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x800000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80000000000000); + if (right_msb == 0){ + let (res) = warp_mul56(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate56(rhs); + let (res_abs) = warp_mul56(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80000000000000); + assert in_range = 1; + let (res) = warp_negate56(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate56(lhs); + let (res_abs) = warp_mul56(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80000000000000); + assert in_range = 1; + let (res) = warp_negate56(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate56(lhs); + let (rhs_abs) = warp_negate56(rhs); + let (res) = warp_mul56(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x8000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000); + if (right_msb == 0){ + let (res) = warp_mul64(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x8000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate64(rhs); + let (res_abs) = warp_mul64(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x8000000000000000); + assert in_range = 1; + let (res) = warp_negate64(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate64(lhs); + let (res_abs) = warp_mul64(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x8000000000000000); + assert in_range = 1; + let (res) = warp_negate64(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate64(lhs); + let (rhs_abs) = warp_negate64(rhs); + let (res) = warp_mul64(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x8000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x800000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000); + if (right_msb == 0){ + let (res) = warp_mul72(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x800000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate72(rhs); + let (res_abs) = warp_mul72(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x800000000000000000); + assert in_range = 1; + let (res) = warp_negate72(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate72(lhs); + let (res_abs) = warp_mul72(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x800000000000000000); + assert in_range = 1; + let (res) = warp_negate72(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate72(lhs); + let (rhs_abs) = warp_negate72(rhs); + let (res) = warp_mul72(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x800000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul80(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate80(rhs); + let (res_abs) = warp_mul80(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000); + assert in_range = 1; + let (res) = warp_negate80(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate80(lhs); + let (res_abs) = warp_mul80(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000); + assert in_range = 1; + let (res) = warp_negate80(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate80(lhs); + let (rhs_abs) = warp_negate80(rhs); + let (res) = warp_mul80(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x8000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul88(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate88(rhs); + let (res_abs) = warp_mul88(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000); + assert in_range = 1; + let (res) = warp_negate88(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate88(lhs); + let (res_abs) = warp_mul88(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000); + assert in_range = 1; + let (res) = warp_negate88(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate88(lhs); + let (rhs_abs) = warp_negate88(rhs); + let (res) = warp_mul88(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x800000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul96(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate96(rhs); + let (res_abs) = warp_mul96(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000); + assert in_range = 1; + let (res) = warp_negate96(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate96(lhs); + let (res_abs) = warp_mul96(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000); + assert in_range = 1; + let (res) = warp_negate96(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate96(lhs); + let (rhs_abs) = warp_negate96(rhs); + let (res) = warp_mul96(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul104(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate104(rhs); + let (res_abs) = warp_mul104(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate104(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate104(lhs); + let (res_abs) = warp_mul104(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate104(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate104(lhs); + let (rhs_abs) = warp_negate104(rhs); + let (res) = warp_mul104(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul112(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate112(rhs); + let (res_abs) = warp_mul112(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate112(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate112(lhs); + let (res_abs) = warp_mul112(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate112(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate112(lhs); + let (rhs_abs) = warp_negate112(rhs); + let (res) = warp_mul112(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul120(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate120(rhs); + let (res_abs) = warp_mul120(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate120(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate120(lhs); + let (res_abs) = warp_mul120(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate120(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate120(lhs); + let (rhs_abs) = warp_negate120(rhs); + let (res) = warp_mul120(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul128(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate128(rhs); + let (res_abs) = warp_mul128(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate128(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate128(lhs); + let (res_abs) = warp_mul128(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate128(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate128(lhs); + let (rhs_abs) = warp_negate128(rhs); + let (res) = warp_mul128(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul136(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate136(rhs); + let (res_abs) = warp_mul136(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate136(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate136(lhs); + let (res_abs) = warp_mul136(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate136(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate136(lhs); + let (rhs_abs) = warp_negate136(rhs); + let (res) = warp_mul136(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul144(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate144(rhs); + let (res_abs) = warp_mul144(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate144(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate144(lhs); + let (res_abs) = warp_mul144(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate144(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate144(lhs); + let (rhs_abs) = warp_negate144(rhs); + let (res) = warp_mul144(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul152(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate152(rhs); + let (res_abs) = warp_mul152(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate152(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate152(lhs); + let (res_abs) = warp_mul152(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate152(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate152(lhs); + let (rhs_abs) = warp_negate152(rhs); + let (res) = warp_mul152(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul160(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate160(rhs); + let (res_abs) = warp_mul160(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate160(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate160(lhs); + let (res_abs) = warp_mul160(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate160(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate160(lhs); + let (rhs_abs) = warp_negate160(rhs); + let (res) = warp_mul160(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul168(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate168(rhs); + let (res_abs) = warp_mul168(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate168(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate168(lhs); + let (res_abs) = warp_mul168(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate168(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate168(lhs); + let (rhs_abs) = warp_negate168(rhs); + let (res) = warp_mul168(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul176(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate176(rhs); + let (res_abs) = warp_mul176(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate176(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate176(lhs); + let (res_abs) = warp_mul176(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate176(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate176(lhs); + let (rhs_abs) = warp_negate176(rhs); + let (res) = warp_mul176(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul184(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate184(rhs); + let (res_abs) = warp_mul184(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate184(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate184(lhs); + let (res_abs) = warp_mul184(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate184(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate184(lhs); + let (rhs_abs) = warp_negate184(rhs); + let (res) = warp_mul184(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul192(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate192(rhs); + let (res_abs) = warp_mul192(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate192(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate192(lhs); + let (res_abs) = warp_mul192(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate192(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate192(lhs); + let (rhs_abs) = warp_negate192(rhs); + let (res) = warp_mul192(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul200(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate200(rhs); + let (res_abs) = warp_mul200(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate200(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate200(lhs); + let (res_abs) = warp_mul200(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate200(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate200(lhs); + let (rhs_abs) = warp_negate200(rhs); + let (res) = warp_mul200(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul208(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate208(rhs); + let (res_abs) = warp_mul208(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate208(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate208(lhs); + let (res_abs) = warp_mul208(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate208(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate208(lhs); + let (rhs_abs) = warp_negate208(rhs); + let (res) = warp_mul208(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul216(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate216(rhs); + let (res_abs) = warp_mul216(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate216(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate216(lhs); + let (res_abs) = warp_mul216(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate216(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate216(lhs); + let (rhs_abs) = warp_negate216(rhs); + let (res) = warp_mul216(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul224(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate224(rhs); + let (res_abs) = warp_mul224(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate224(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate224(lhs); + let (res_abs) = warp_mul224(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate224(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate224(lhs); + let (rhs_abs) = warp_negate224(rhs); + let (res) = warp_mul224(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul232(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate232(rhs); + let (res_abs) = warp_mul232(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate232(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate232(lhs); + let (res_abs) = warp_mul232(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate232(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate232(lhs); + let (rhs_abs) = warp_negate232(rhs); + let (res) = warp_mul232(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul240(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate240(rhs); + let (res_abs) = warp_mul240(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate240(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate240(lhs); + let (res_abs) = warp_mul240(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate240(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate240(lhs); + let (rhs_abs) = warp_negate240(rhs); + let (res) = warp_mul240(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul248(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate248(rhs); + let (res_abs) = warp_mul248(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate248(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate248(lhs); + let (res_abs) = warp_mul248(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate248(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate248(lhs); + let (rhs_abs) = warp_negate248(rhs); + let (res) = warp_mul248(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : Uint256, rhs : Uint256) -> (result : Uint256){ + alloc_locals; + // 1 => lhs >= 0, 0 => lhs < 0 + let (lhs_nn) = uint256_signed_nn(lhs); + // 1 => rhs >= 0, 0 => rhs < 0 + let (local rhs_nn) = uint256_signed_nn(rhs); + // negates if arg is 1, which is if lhs_nn is 0, which is if lhs < 0 + let (lhs_abs) = uint256_cond_neg(lhs, 1 - lhs_nn); + // negates if arg is 1 + let (rhs_abs) = uint256_cond_neg(rhs, 1 - rhs_nn); + let (res_abs, overflow) = uint256_mul(lhs_abs, rhs_abs); + assert overflow.low = 0; + assert overflow.high = 0; + let res_should_be_neg = lhs_nn + rhs_nn; + if (res_should_be_neg == 1){ + let (in_range) = uint256_le(res_abs, Uint256(0,0x80000000000000000000000000000000)); + assert in_range = 1; + let (negated) = uint256_neg(res_abs); + return (negated,); + }else{ + let (msb) = bitwise_and(res_abs.high, 0x80000000000000000000000000000000); + assert msb = 0; + return (res_abs,); + } +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/mul_signed_unsafe.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/mul_signed_unsafe.cairo new file mode 100644 index 000000000..00733b654 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/mul_signed_unsafe.cairo @@ -0,0 +1,454 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.math_cmp import is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_mul, uint256_cond_neg, uint256_signed_nn +from warplib.maths.mul_unsafe import warp_mul_unsafe8, warp_mul_unsafe16, warp_mul_unsafe24, warp_mul_unsafe32, warp_mul_unsafe40, warp_mul_unsafe48, warp_mul_unsafe56, warp_mul_unsafe64, warp_mul_unsafe72, warp_mul_unsafe80, warp_mul_unsafe88, warp_mul_unsafe96, warp_mul_unsafe104, warp_mul_unsafe112, warp_mul_unsafe120, warp_mul_unsafe128, warp_mul_unsafe136, warp_mul_unsafe144, warp_mul_unsafe152, warp_mul_unsafe160, warp_mul_unsafe168, warp_mul_unsafe176, warp_mul_unsafe184, warp_mul_unsafe192, warp_mul_unsafe200, warp_mul_unsafe208, warp_mul_unsafe216, warp_mul_unsafe224, warp_mul_unsafe232, warp_mul_unsafe240, warp_mul_unsafe248 +from warplib.maths.negate import warp_negate8, warp_negate16, warp_negate24, warp_negate32, warp_negate40, warp_negate48, warp_negate56, warp_negate64, warp_negate72, warp_negate80, warp_negate88, warp_negate96, warp_negate104, warp_negate112, warp_negate120, warp_negate128, warp_negate136, warp_negate144, warp_negate152, warp_negate160, warp_negate168, warp_negate176, warp_negate184, warp_negate192, warp_negate200, warp_negate208, warp_negate216, warp_negate224, warp_negate232, warp_negate240, warp_negate248 +from warplib.maths.utils import felt_to_uint256 + +func warp_mul_signed_unsafe8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80); + let (local right_msb) = bitwise_and(rhs, 0x80); + let (res) = warp_mul_unsafe8(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100 - left_msb - right_msb); + if (not_neg == 0x80){ + let (res) = warp_negate8(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x8000); + let (local right_msb) = bitwise_and(rhs, 0x8000); + let (res) = warp_mul_unsafe16(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x10000 - left_msb - right_msb); + if (not_neg == 0x8000){ + let (res) = warp_negate16(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x800000); + let (local right_msb) = bitwise_and(rhs, 0x800000); + let (res) = warp_mul_unsafe24(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x1000000 - left_msb - right_msb); + if (not_neg == 0x800000){ + let (res) = warp_negate24(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80000000); + let (local right_msb) = bitwise_and(rhs, 0x80000000); + let (res) = warp_mul_unsafe32(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100000000 - left_msb - right_msb); + if (not_neg == 0x80000000){ + let (res) = warp_negate32(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x8000000000); + let (local right_msb) = bitwise_and(rhs, 0x8000000000); + let (res) = warp_mul_unsafe40(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x10000000000 - left_msb - right_msb); + if (not_neg == 0x8000000000){ + let (res) = warp_negate40(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x800000000000); + let (local right_msb) = bitwise_and(rhs, 0x800000000000); + let (res) = warp_mul_unsafe48(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x1000000000000 - left_msb - right_msb); + if (not_neg == 0x800000000000){ + let (res) = warp_negate48(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80000000000000); + let (local right_msb) = bitwise_and(rhs, 0x80000000000000); + let (res) = warp_mul_unsafe56(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100000000000000 - left_msb - right_msb); + if (not_neg == 0x80000000000000){ + let (res) = warp_negate56(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x8000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x8000000000000000); + let (res) = warp_mul_unsafe64(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x10000000000000000 - left_msb - right_msb); + if (not_neg == 0x8000000000000000){ + let (res) = warp_negate64(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x800000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x800000000000000000); + let (res) = warp_mul_unsafe72(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x1000000000000000000 - left_msb - right_msb); + if (not_neg == 0x800000000000000000){ + let (res) = warp_negate72(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x80000000000000000000); + let (res) = warp_mul_unsafe80(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100000000000000000000 - left_msb - right_msb); + if (not_neg == 0x80000000000000000000){ + let (res) = warp_negate80(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x8000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x8000000000000000000000); + let (res) = warp_mul_unsafe88(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x10000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x8000000000000000000000){ + let (res) = warp_negate88(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x800000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x800000000000000000000000); + let (res) = warp_mul_unsafe96(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x1000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x800000000000000000000000){ + let (res) = warp_negate96(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x80000000000000000000000000); + let (res) = warp_mul_unsafe104(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x80000000000000000000000000){ + let (res) = warp_negate104(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000); + let (res) = warp_mul_unsafe112(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x10000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x8000000000000000000000000000){ + let (res) = warp_negate112(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000); + let (res) = warp_mul_unsafe120(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x1000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x800000000000000000000000000000){ + let (res) = warp_negate120(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000); + let (res) = warp_mul_unsafe128(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x80000000000000000000000000000000){ + let (res) = warp_negate128(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000); + let (res) = warp_mul_unsafe136(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x10000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x8000000000000000000000000000000000){ + let (res) = warp_negate136(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000); + let (res) = warp_mul_unsafe144(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x1000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x800000000000000000000000000000000000){ + let (res) = warp_negate144(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000); + let (res) = warp_mul_unsafe152(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x80000000000000000000000000000000000000){ + let (res) = warp_negate152(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe160(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x10000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x8000000000000000000000000000000000000000){ + let (res) = warp_negate160(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe168(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x1000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x800000000000000000000000000000000000000000){ + let (res) = warp_negate168(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe176(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x80000000000000000000000000000000000000000000){ + let (res) = warp_negate176(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe184(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x10000000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x8000000000000000000000000000000000000000000000){ + let (res) = warp_negate184(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe192(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x1000000000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x800000000000000000000000000000000000000000000000){ + let (res) = warp_negate192(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe200(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100000000000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x80000000000000000000000000000000000000000000000000){ + let (res) = warp_negate200(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe208(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x10000000000000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x8000000000000000000000000000000000000000000000000000){ + let (res) = warp_negate208(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe216(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x1000000000000000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x800000000000000000000000000000000000000000000000000000){ + let (res) = warp_negate216(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe224(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100000000000000000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x80000000000000000000000000000000000000000000000000000000){ + let (res) = warp_negate224(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe232(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x10000000000000000000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x8000000000000000000000000000000000000000000000000000000000){ + let (res) = warp_negate232(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe240(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x1000000000000000000000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x800000000000000000000000000000000000000000000000000000000000){ + let (res) = warp_negate240(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe248(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100000000000000000000000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x80000000000000000000000000000000000000000000000000000000000000){ + let (res) = warp_negate248(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : Uint256, rhs : Uint256) -> (result : Uint256){ + alloc_locals; + let (lhs_nn) = uint256_signed_nn(lhs); + let (local rhs_nn) = uint256_signed_nn(rhs); + let (lhs_abs) = uint256_cond_neg(lhs, lhs_nn); + let (rhs_abs) = uint256_cond_neg(rhs, rhs_nn); + let (res_abs, _) = uint256_mul(lhs_abs, rhs_abs); + let (res) = uint256_cond_neg(res_abs, (lhs_nn + rhs_nn) * (2 - lhs_nn - rhs_nn)); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/mul_unsafe.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/mul_unsafe.cairo new file mode 100644 index 000000000..1b082c6b4 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/mul_unsafe.cairo @@ -0,0 +1,198 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_mul +from warplib.maths.utils import felt_to_uint256 + +func warp_mul_unsafe8{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xff); + return (res,); +} +func warp_mul_unsafe16{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffff); + return (res,); +} +func warp_mul_unsafe24{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffff); + return (res,); +} +func warp_mul_unsafe32{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffff); + return (res,); +} +func warp_mul_unsafe40{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffff); + return (res,); +} +func warp_mul_unsafe48{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffffff); + return (res,); +} +func warp_mul_unsafe56{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffffffff); + return (res,); +} +func warp_mul_unsafe64{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffffffffff); + return (res,); +} +func warp_mul_unsafe72{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffffffffffff); + return (res,); +} +func warp_mul_unsafe80{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffffffffffffff); + return (res,); +} +func warp_mul_unsafe88{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffffffffffffffff); + return (res,); +} +func warp_mul_unsafe96{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_mul_unsafe104{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_mul_unsafe112{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_mul_unsafe120{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_mul_unsafe128{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0x0); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe136{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe144{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe152{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe160{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe168{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe176{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe184{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe192{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe200{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe208{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffffffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe216{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffffffffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe224{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffffffffffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe232{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffffffffffffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe240{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffffffffffffffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe248{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffffffffffffffffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe256{range_check_ptr}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + let (res : Uint256, _) = uint256_mul(lhs, rhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/mulmod.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/mulmod.cairo new file mode 100644 index 000000000..6835b38a7 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/mulmod.cairo @@ -0,0 +1,38 @@ +from starkware.cairo.common.uint256 import ( + Uint256, + uint256_unsigned_div_rem, + uint256_add, + uint256_mul, + uint256_sub, + ALL_ONES, +) +from warplib.maths.utils import felt_to_uint256 +from warplib.maths.addmod import warp_addmod + +func warp_mulmod{range_check_ptr}(x: Uint256, y: Uint256, k: Uint256) -> (res: Uint256) { + alloc_locals; + if (k.high + k.low == 0) { + with_attr error_message("Modulo by zero error") { + assert 1 = 0; + } + } + + let (xy_low, xy_high) = uint256_mul(x, y); + if (xy_high.low + xy_high.high == 0) { + let (_, res) = uint256_unsigned_div_rem(xy_low, k); + return (res,); + } + + let uint256_MAX = Uint256(low=ALL_ONES, high=ALL_ONES); + let (_, exp_mod_k) = uint256_unsigned_div_rem(uint256_MAX, k); + let (exp_mod_k, _) = uint256_add(exp_mod_k, Uint256(1, 0)); + let (_, exp_mod_k) = uint256_unsigned_div_rem(exp_mod_k, k); + + let (_, xy_high_mod_k) = uint256_unsigned_div_rem(xy_high, k); + let (_, xy_low_mod_k) = uint256_unsigned_div_rem(xy_low, k); + + let (xy_high_exp_mod_k) = warp_mulmod(exp_mod_k, xy_high_mod_k, k); + let (res) = warp_addmod(xy_high_exp_mod_k, xy_low_mod_k, k); + + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/negate.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/negate.cairo new file mode 100644 index 000000000..3e88ea589 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/negate.cairo @@ -0,0 +1,164 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_neg + +func warp_negate8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100 - op; + let (res) = bitwise_and(raw_res, 0xff); + return (res,); +} +func warp_negate16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x10000 - op; + let (res) = bitwise_and(raw_res, 0xffff); + return (res,); +} +func warp_negate24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x1000000 - op; + let (res) = bitwise_and(raw_res, 0xffffff); + return (res,); +} +func warp_negate32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffff); + return (res,); +} +func warp_negate40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x10000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffff); + return (res,); +} +func warp_negate48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x1000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffff); + return (res,); +} +func warp_negate56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffff); + return (res,); +} +func warp_negate64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x10000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffff); + return (res,); +} +func warp_negate72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x1000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffff); + return (res,); +} +func warp_negate80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffff); + return (res,); +} +func warp_negate88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x10000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffff); + return (res,); +} +func warp_negate96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x1000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_negate104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_negate112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x10000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x1000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x10000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x1000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x10000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x1000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate184{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x10000000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate192{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x1000000000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate200{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100000000000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate208{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x10000000000000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate216{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x1000000000000000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate224{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100000000000000000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate232{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x10000000000000000000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate240{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x1000000000000000000000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate248{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100000000000000000000000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate256{range_check_ptr}(op : Uint256) -> (res : Uint256){ + let (res) = uint256_neg(op); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/neq.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/neq.cairo new file mode 100644 index 000000000..8a04eef18 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/neq.cairo @@ -0,0 +1,14 @@ +from starkware.cairo.common.uint256 import Uint256, uint256_eq + +func warp_neq(lhs: felt, rhs: felt) -> (res: felt) { + if (lhs == rhs) { + return (0,); + } else { + return (1,); + } +} + +func warp_neq256{range_check_ptr}(lhs: Uint256, rhs: Uint256) -> (res: felt) { + let (res: felt) = uint256_eq(lhs, rhs); + return (1 - res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/or.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/or.cairo new file mode 100644 index 000000000..96fef5e4f --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/or.cairo @@ -0,0 +1,7 @@ +func warp_or(lhs: felt, rhs: felt) -> (res: felt) { + let val = lhs + rhs; + if (val == 0) { + return (0,); + } + return (1,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/pow2.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/pow2.cairo new file mode 100644 index 000000000..98da0afee --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/pow2.cairo @@ -0,0 +1,267 @@ +from starkware.cairo.common.uint256 import Uint256 +from starkware.cairo.common.registers import get_label_location +from warplib.maths.utils import felt_to_uint256 + +func pow2(i) -> (res: felt) { + let (data_address) = get_label_location(data); + return ([data_address + i],); + + data: + dw 0x1; + dw 0x2; + dw 0x4; + dw 0x8; + dw 0x10; + dw 0x20; + dw 0x40; + dw 0x80; + dw 0x100; + dw 0x200; + dw 0x400; + dw 0x800; + dw 0x1000; + dw 0x2000; + dw 0x4000; + dw 0x8000; + dw 0x10000; + dw 0x20000; + dw 0x40000; + dw 0x80000; + dw 0x100000; + dw 0x200000; + dw 0x400000; + dw 0x800000; + dw 0x1000000; + dw 0x2000000; + dw 0x4000000; + dw 0x8000000; + dw 0x10000000; + dw 0x20000000; + dw 0x40000000; + dw 0x80000000; + dw 0x100000000; + dw 0x200000000; + dw 0x400000000; + dw 0x800000000; + dw 0x1000000000; + dw 0x2000000000; + dw 0x4000000000; + dw 0x8000000000; + dw 0x10000000000; + dw 0x20000000000; + dw 0x40000000000; + dw 0x80000000000; + dw 0x100000000000; + dw 0x200000000000; + dw 0x400000000000; + dw 0x800000000000; + dw 0x1000000000000; + dw 0x2000000000000; + dw 0x4000000000000; + dw 0x8000000000000; + dw 0x10000000000000; + dw 0x20000000000000; + dw 0x40000000000000; + dw 0x80000000000000; + dw 0x100000000000000; + dw 0x200000000000000; + dw 0x400000000000000; + dw 0x800000000000000; + dw 0x1000000000000000; + dw 0x2000000000000000; + dw 0x4000000000000000; + dw 0x8000000000000000; + dw 0x10000000000000000; + dw 0x20000000000000000; + dw 0x40000000000000000; + dw 0x80000000000000000; + dw 0x100000000000000000; + dw 0x200000000000000000; + dw 0x400000000000000000; + dw 0x800000000000000000; + dw 0x1000000000000000000; + dw 0x2000000000000000000; + dw 0x4000000000000000000; + dw 0x8000000000000000000; + dw 0x10000000000000000000; + dw 0x20000000000000000000; + dw 0x40000000000000000000; + dw 0x80000000000000000000; + dw 0x100000000000000000000; + dw 0x200000000000000000000; + dw 0x400000000000000000000; + dw 0x800000000000000000000; + dw 0x1000000000000000000000; + dw 0x2000000000000000000000; + dw 0x4000000000000000000000; + dw 0x8000000000000000000000; + dw 0x10000000000000000000000; + dw 0x20000000000000000000000; + dw 0x40000000000000000000000; + dw 0x80000000000000000000000; + dw 0x100000000000000000000000; + dw 0x200000000000000000000000; + dw 0x400000000000000000000000; + dw 0x800000000000000000000000; + dw 0x1000000000000000000000000; + dw 0x2000000000000000000000000; + dw 0x4000000000000000000000000; + dw 0x8000000000000000000000000; + dw 0x10000000000000000000000000; + dw 0x20000000000000000000000000; + dw 0x40000000000000000000000000; + dw 0x80000000000000000000000000; + dw 0x100000000000000000000000000; + dw 0x200000000000000000000000000; + dw 0x400000000000000000000000000; + dw 0x800000000000000000000000000; + dw 0x1000000000000000000000000000; + dw 0x2000000000000000000000000000; + dw 0x4000000000000000000000000000; + dw 0x8000000000000000000000000000; + dw 0x10000000000000000000000000000; + dw 0x20000000000000000000000000000; + dw 0x40000000000000000000000000000; + dw 0x80000000000000000000000000000; + dw 0x100000000000000000000000000000; + dw 0x200000000000000000000000000000; + dw 0x400000000000000000000000000000; + dw 0x800000000000000000000000000000; + dw 0x1000000000000000000000000000000; + dw 0x2000000000000000000000000000000; + dw 0x4000000000000000000000000000000; + dw 0x8000000000000000000000000000000; + dw 0x10000000000000000000000000000000; + dw 0x20000000000000000000000000000000; + dw 0x40000000000000000000000000000000; + dw 0x80000000000000000000000000000000; + dw 0x100000000000000000000000000000000; + dw 0x200000000000000000000000000000000; + dw 0x400000000000000000000000000000000; + dw 0x800000000000000000000000000000000; + dw 0x1000000000000000000000000000000000; + dw 0x2000000000000000000000000000000000; + dw 0x4000000000000000000000000000000000; + dw 0x8000000000000000000000000000000000; + dw 0x10000000000000000000000000000000000; + dw 0x20000000000000000000000000000000000; + dw 0x40000000000000000000000000000000000; + dw 0x80000000000000000000000000000000000; + dw 0x100000000000000000000000000000000000; + dw 0x200000000000000000000000000000000000; + dw 0x400000000000000000000000000000000000; + dw 0x800000000000000000000000000000000000; + dw 0x1000000000000000000000000000000000000; + dw 0x2000000000000000000000000000000000000; + dw 0x4000000000000000000000000000000000000; + dw 0x8000000000000000000000000000000000000; + dw 0x10000000000000000000000000000000000000; + dw 0x20000000000000000000000000000000000000; + dw 0x40000000000000000000000000000000000000; + dw 0x80000000000000000000000000000000000000; + dw 0x100000000000000000000000000000000000000; + dw 0x200000000000000000000000000000000000000; + dw 0x400000000000000000000000000000000000000; + dw 0x800000000000000000000000000000000000000; + dw 0x1000000000000000000000000000000000000000; + dw 0x2000000000000000000000000000000000000000; + dw 0x4000000000000000000000000000000000000000; + dw 0x8000000000000000000000000000000000000000; + dw 0x10000000000000000000000000000000000000000; + dw 0x20000000000000000000000000000000000000000; + dw 0x40000000000000000000000000000000000000000; + dw 0x80000000000000000000000000000000000000000; + dw 0x100000000000000000000000000000000000000000; + dw 0x200000000000000000000000000000000000000000; + dw 0x400000000000000000000000000000000000000000; + dw 0x800000000000000000000000000000000000000000; + dw 0x1000000000000000000000000000000000000000000; + dw 0x2000000000000000000000000000000000000000000; + dw 0x4000000000000000000000000000000000000000000; + dw 0x8000000000000000000000000000000000000000000; + dw 0x10000000000000000000000000000000000000000000; + dw 0x20000000000000000000000000000000000000000000; + dw 0x40000000000000000000000000000000000000000000; + dw 0x80000000000000000000000000000000000000000000; + dw 0x100000000000000000000000000000000000000000000; + dw 0x200000000000000000000000000000000000000000000; + dw 0x400000000000000000000000000000000000000000000; + dw 0x800000000000000000000000000000000000000000000; + dw 0x1000000000000000000000000000000000000000000000; + dw 0x2000000000000000000000000000000000000000000000; + dw 0x4000000000000000000000000000000000000000000000; + dw 0x8000000000000000000000000000000000000000000000; + dw 0x10000000000000000000000000000000000000000000000; + dw 0x20000000000000000000000000000000000000000000000; + dw 0x40000000000000000000000000000000000000000000000; + dw 0x80000000000000000000000000000000000000000000000; + dw 0x100000000000000000000000000000000000000000000000; + dw 0x200000000000000000000000000000000000000000000000; + dw 0x400000000000000000000000000000000000000000000000; + dw 0x800000000000000000000000000000000000000000000000; + dw 0x1000000000000000000000000000000000000000000000000; + dw 0x2000000000000000000000000000000000000000000000000; + dw 0x4000000000000000000000000000000000000000000000000; + dw 0x8000000000000000000000000000000000000000000000000; + dw 0x10000000000000000000000000000000000000000000000000; + dw 0x20000000000000000000000000000000000000000000000000; + dw 0x40000000000000000000000000000000000000000000000000; + dw 0x80000000000000000000000000000000000000000000000000; + dw 0x100000000000000000000000000000000000000000000000000; + dw 0x200000000000000000000000000000000000000000000000000; + dw 0x400000000000000000000000000000000000000000000000000; + dw 0x800000000000000000000000000000000000000000000000000; + dw 0x1000000000000000000000000000000000000000000000000000; + dw 0x2000000000000000000000000000000000000000000000000000; + dw 0x4000000000000000000000000000000000000000000000000000; + dw 0x8000000000000000000000000000000000000000000000000000; + dw 0x10000000000000000000000000000000000000000000000000000; + dw 0x20000000000000000000000000000000000000000000000000000; + dw 0x40000000000000000000000000000000000000000000000000000; + dw 0x80000000000000000000000000000000000000000000000000000; + dw 0x100000000000000000000000000000000000000000000000000000; + dw 0x200000000000000000000000000000000000000000000000000000; + dw 0x400000000000000000000000000000000000000000000000000000; + dw 0x800000000000000000000000000000000000000000000000000000; + dw 0x1000000000000000000000000000000000000000000000000000000; + dw 0x2000000000000000000000000000000000000000000000000000000; + dw 0x4000000000000000000000000000000000000000000000000000000; + dw 0x8000000000000000000000000000000000000000000000000000000; + dw 0x10000000000000000000000000000000000000000000000000000000; + dw 0x20000000000000000000000000000000000000000000000000000000; + dw 0x40000000000000000000000000000000000000000000000000000000; + dw 0x80000000000000000000000000000000000000000000000000000000; + dw 0x100000000000000000000000000000000000000000000000000000000; + dw 0x200000000000000000000000000000000000000000000000000000000; + dw 0x400000000000000000000000000000000000000000000000000000000; + dw 0x800000000000000000000000000000000000000000000000000000000; + dw 0x1000000000000000000000000000000000000000000000000000000000; + dw 0x2000000000000000000000000000000000000000000000000000000000; + dw 0x4000000000000000000000000000000000000000000000000000000000; + dw 0x8000000000000000000000000000000000000000000000000000000000; + dw 0x10000000000000000000000000000000000000000000000000000000000; + dw 0x20000000000000000000000000000000000000000000000000000000000; + dw 0x40000000000000000000000000000000000000000000000000000000000; + dw 0x80000000000000000000000000000000000000000000000000000000000; + dw 0x100000000000000000000000000000000000000000000000000000000000; + dw 0x200000000000000000000000000000000000000000000000000000000000; + dw 0x400000000000000000000000000000000000000000000000000000000000; + dw 0x800000000000000000000000000000000000000000000000000000000000; + dw 0x1000000000000000000000000000000000000000000000000000000000000; + dw 0x2000000000000000000000000000000000000000000000000000000000000; + dw 0x4000000000000000000000000000000000000000000000000000000000000; + dw 0x8000000000000000000000000000000000000000000000000000000000000; + dw 0x10000000000000000000000000000000000000000000000000000000000000; + dw 0x20000000000000000000000000000000000000000000000000000000000000; + dw 0x40000000000000000000000000000000000000000000000000000000000000; + dw 0x80000000000000000000000000000000000000000000000000000000000000; + dw 0x100000000000000000000000000000000000000000000000000000000000000; + dw 0x200000000000000000000000000000000000000000000000000000000000000; + dw 0x400000000000000000000000000000000000000000000000000000000000000; +} + +func u256_pow2{range_check_ptr}(i) -> (res: Uint256) { + let (felt_pow2) = pow2(i); + let (res) = felt_to_uint256(felt_pow2); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/shl.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/shl.cairo new file mode 100644 index 000000000..db4520410 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/shl.cairo @@ -0,0 +1,730 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.math import split_felt +from starkware.cairo.common.math_cmp import is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_shl +from warplib.maths.pow2 import pow2 + +func warp_shl8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(8, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 8 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl8_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl8(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(16, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 16 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl16_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl16(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(24, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 24 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl24_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl24(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(32, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 32 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl32_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl32(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(40, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 40 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl40_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl40(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(48, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 48 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl48_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl48(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(56, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 56 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl56_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl56(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(64, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 64 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl64_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl64(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(72, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 72 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl72_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl72(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(80, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 80 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl80_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl80(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(88, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 88 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl88_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl88(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(96, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 96 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl96_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl96(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(104, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 104 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl104_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl104(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(112, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 112 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl112_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl112(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(120, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 120 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl120_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl120(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(128, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 128 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl128_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl128(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(136, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 136 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl136_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl136(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(144, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 144 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl144_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl144(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(152, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 152 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl152_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl152(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(160, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 160 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl160_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl160(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(168, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 168 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl168_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl168(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(176, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 176 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl176_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl176(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(184, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 184 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl184_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl184(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(192, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 192 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl192_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl192(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(200, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 200 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl200_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl200(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(208, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 208 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl208_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl208(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(216, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 216 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl216_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl216(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(224, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 224 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl224_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl224(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(232, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 232 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl232_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl232(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(240, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 240 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl240_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl240(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(248, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 248 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl248_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl248(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl256{range_check_ptr}(lhs : Uint256, rhs : felt) -> (result : Uint256){ + let (high, low) = split_felt(rhs); + let (res) = uint256_shl(lhs, Uint256(low, high)); + return (res,); +} +func warp_shl256_256{range_check_ptr}(lhs : Uint256, rhs : Uint256) -> (result : Uint256){ + let (res) = uint256_shl(lhs, rhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/shr.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/shr.cairo new file mode 100644 index 000000000..efe3c350c --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/shr.cairo @@ -0,0 +1,808 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and, bitwise_not +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.math_cmp import is_le, is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_and +from warplib.maths.pow2 import pow2 + +func warp_shr8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(8, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 8 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr8_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr8(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(16, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 16 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr16_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr16(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(24, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 24 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr24_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr24(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(32, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 32 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr32_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr32(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(40, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 40 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr40_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr40(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(48, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 48 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr48_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr48(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(56, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 56 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr56_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr56(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(64, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 64 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr64_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr64(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(72, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 72 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr72_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr72(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(80, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 80 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr80_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr80(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(88, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 88 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr88_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr88(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(96, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 96 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr96_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr96(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(104, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 104 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr104_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr104(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(112, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 112 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr112_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr112(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(120, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 120 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr120_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr120(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(128, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 128 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr128_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr128(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(136, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 136 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr136_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr136(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(144, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 144 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr144_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr144(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(152, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 152 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr152_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr152(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(160, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 160 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr160_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr160(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(168, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 168 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr168_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr168(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(176, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 176 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr176_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr176(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(184, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 184 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr184_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr184(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(192, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 192 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr192_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr192(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(200, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 200 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr200_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr200(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(208, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 208 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr208_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr208(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(216, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 216 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr216_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr216(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(224, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 224 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr224_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr224(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(232, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 232 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr232_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr232(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(240, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 240 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr240_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr240(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(248, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 248 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr248_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr248(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : felt) -> ( + result : Uint256){ + let le_127 = is_le(rhs, 127); + if (le_127 == 1){ + // (h', l') := (h, l) >> rhs + // p := 2^rhs + // l' = ((h & (p-1)) << (128 - rhs)) + ((l&~(p-1)) >> rhs) + // = ((h & (p-1)) << 128 >> rhs) + ((l&~(p-1)) >> rhs) + // = (h & (p-1)) * 2^128 / p + (l&~(p-1)) / p + // = (h & (p-1) * 2^128 + l&~(p-1)) / p + // h' = h >> rhs = (h - h&(p-1)) / p + let (p) = pow2(rhs); + let (low_mask) = bitwise_not(p - 1); + let (low_part) = bitwise_and(lhs.low, low_mask); + let (high_part) = bitwise_and(lhs.high, p - 1); + return ( + Uint256(low=(low_part + 0x100000000000000000000000000000000 * high_part) / p, high=(lhs.high - high_part) / p),); + } + let le_255 = is_le(rhs, 255); + if (le_255 == 1){ + let (p) = pow2(rhs - 128); + let (mask) = bitwise_not(p - 1); + let (res) = bitwise_and(lhs.high, mask); + return (Uint256(res / p, 0),); + } + return (Uint256(0, 0),); +} +func warp_shr256_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : Uint256) -> ( + result : Uint256){ + if (rhs.high != 0){ + return (Uint256(0, 0),); + } + let le_127 = is_le(rhs.low, 127); + if (le_127 == 1){ + // (h', l') := (h, l) >> rhs + // p := 2^rhs + // l' = ((h & (p-1)) << (128 - rhs)) + ((l&~(p-1)) >> rhs) + // = ((h & (p-1)) << 128 >> rhs) + ((l&~(p-1)) >> rhs) + // = (h & (p-1)) * 2^128 / p + (l&~(p-1)) / p + // = (h & (p-1) * 2^128 + l&~(p-1)) / p + // h' = h >> rhs = (h - h&(p-1)) / p + let (p) = pow2(rhs.low); + let (low_mask) = bitwise_not(p - 1); + let (low_part) = bitwise_and(lhs.low, low_mask); + let (high_part) = bitwise_and(lhs.high, p - 1); + return ( + Uint256(low=(low_part + 0x100000000000000000000000000000000 * high_part) / p, high=(lhs.high - high_part) / p),); + } + let le_255 = is_le(rhs.low, 255); + if (le_255 == 1){ + let (p) = pow2(rhs.low - 128); + let (mask) = bitwise_not(p - 1); + let (res) = bitwise_and(lhs.high, mask); + return (Uint256(res / p, 0),); + } + return (Uint256(0, 0),); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/shr_signed.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/shr_signed.cairo new file mode 100644 index 000000000..0121a3000 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/shr_signed.cairo @@ -0,0 +1,1004 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.math_cmp import is_le, is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_and +from warplib.maths.pow2 import pow2 +from warplib.maths.shr import warp_shr8, warp_shr16, warp_shr24, warp_shr32, warp_shr40, warp_shr48, warp_shr56, warp_shr64, warp_shr72, warp_shr80, warp_shr88, warp_shr96, warp_shr104, warp_shr112, warp_shr120, warp_shr128, warp_shr136, warp_shr144, warp_shr152, warp_shr160, warp_shr168, warp_shr176, warp_shr184, warp_shr192, warp_shr200, warp_shr208, warp_shr216, warp_shr224, warp_shr232, warp_shr240, warp_shr248, warp_shr256 + +func warp_shr_signed8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr8(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(8, rhs); + if (large_shift == 1){ + return (0xff,); + }else{ + let (shifted) = warp_shr8(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(8 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed8_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr8(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr8(lhs, 8); + return (res,); + } +} +func warp_shr_signed16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x8000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr16(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(16, rhs); + if (large_shift == 1){ + return (0xffff,); + }else{ + let (shifted) = warp_shr16(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(16 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed16_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr16(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr16(lhs, 16); + return (res,); + } +} +func warp_shr_signed24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x800000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr24(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(24, rhs); + if (large_shift == 1){ + return (0xffffff,); + }else{ + let (shifted) = warp_shr24(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(24 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed24_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr24(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr24(lhs, 24); + return (res,); + } +} +func warp_shr_signed32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr32(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(32, rhs); + if (large_shift == 1){ + return (0xffffffff,); + }else{ + let (shifted) = warp_shr32(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(32 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed32_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr32(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr32(lhs, 32); + return (res,); + } +} +func warp_shr_signed40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x8000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr40(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(40, rhs); + if (large_shift == 1){ + return (0xffffffffff,); + }else{ + let (shifted) = warp_shr40(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(40 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed40_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr40(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr40(lhs, 40); + return (res,); + } +} +func warp_shr_signed48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x800000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr48(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(48, rhs); + if (large_shift == 1){ + return (0xffffffffffff,); + }else{ + let (shifted) = warp_shr48(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(48 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed48_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr48(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr48(lhs, 48); + return (res,); + } +} +func warp_shr_signed56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr56(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(56, rhs); + if (large_shift == 1){ + return (0xffffffffffffff,); + }else{ + let (shifted) = warp_shr56(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(56 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed56_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr56(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr56(lhs, 56); + return (res,); + } +} +func warp_shr_signed64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x8000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr64(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(64, rhs); + if (large_shift == 1){ + return (0xffffffffffffffff,); + }else{ + let (shifted) = warp_shr64(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(64 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed64_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr64(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr64(lhs, 64); + return (res,); + } +} +func warp_shr_signed72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x800000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr72(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(72, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffff,); + }else{ + let (shifted) = warp_shr72(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(72 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed72_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr72(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr72(lhs, 72); + return (res,); + } +} +func warp_shr_signed80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr80(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(80, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr80(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(80 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed80_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr80(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr80(lhs, 80); + return (res,); + } +} +func warp_shr_signed88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x8000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr88(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(88, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr88(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(88 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed88_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr88(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr88(lhs, 88); + return (res,); + } +} +func warp_shr_signed96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x800000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr96(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(96, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr96(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(96 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed96_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr96(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr96(lhs, 96); + return (res,); + } +} +func warp_shr_signed104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr104(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(104, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr104(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(104 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed104_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr104(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr104(lhs, 104); + return (res,); + } +} +func warp_shr_signed112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x8000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr112(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(112, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr112(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(112 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed112_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr112(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr112(lhs, 112); + return (res,); + } +} +func warp_shr_signed120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x800000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr120(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(120, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr120(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(120 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed120_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr120(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr120(lhs, 120); + return (res,); + } +} +func warp_shr_signed128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr128(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(128, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr128(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(128 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed128_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr128(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr128(lhs, 128); + return (res,); + } +} +func warp_shr_signed136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr136(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(136, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr136(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(136 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed136_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr136(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr136(lhs, 136); + return (res,); + } +} +func warp_shr_signed144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr144(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(144, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr144(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(144 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed144_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr144(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr144(lhs, 144); + return (res,); + } +} +func warp_shr_signed152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr152(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(152, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr152(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(152 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed152_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr152(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr152(lhs, 152); + return (res,); + } +} +func warp_shr_signed160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr160(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(160, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr160(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(160 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed160_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr160(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr160(lhs, 160); + return (res,); + } +} +func warp_shr_signed168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr168(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(168, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr168(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(168 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed168_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr168(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr168(lhs, 168); + return (res,); + } +} +func warp_shr_signed176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr176(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(176, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr176(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(176 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed176_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr176(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr176(lhs, 176); + return (res,); + } +} +func warp_shr_signed184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr184(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(184, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr184(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(184 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed184_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr184(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr184(lhs, 184); + return (res,); + } +} +func warp_shr_signed192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr192(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(192, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr192(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(192 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed192_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr192(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr192(lhs, 192); + return (res,); + } +} +func warp_shr_signed200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr200(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(200, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr200(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(200 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed200_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr200(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr200(lhs, 200); + return (res,); + } +} +func warp_shr_signed208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr208(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(208, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr208(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(208 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed208_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr208(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr208(lhs, 208); + return (res,); + } +} +func warp_shr_signed216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr216(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(216, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr216(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(216 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed216_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr216(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr216(lhs, 216); + return (res,); + } +} +func warp_shr_signed224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr224(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(224, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr224(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(224 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed224_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr224(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr224(lhs, 224); + return (res,); + } +} +func warp_shr_signed232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr232(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(232, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr232(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(232 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed232_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr232(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr232(lhs, 232); + return (res,); + } +} +func warp_shr_signed240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr240(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(240, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr240(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(240 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed240_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr240(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr240(lhs, 240); + return (res,); + } +} +func warp_shr_signed248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr248(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(248, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr248(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(248 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed248_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr248(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr248(lhs, 248); + return (res,); + } +} +func warp_shr_signed256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : felt) -> (res : Uint256){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs.high, 0x80000000000000000000000000000000); + let (logical_shift) = warp_shr256(lhs, rhs); + if (lhs_msb == 0){ + return (logical_shift,); + }else{ + let large_shift = is_le(256, rhs); + if (large_shift == 1){ + return (Uint256(0xffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffff),); + }else{ + let crosses_boundary = is_le(128, rhs); + if (crosses_boundary == 1){ + let (bound) = pow2(rhs-128); + let ones = bound - 1; + let (shift) = pow2(256-rhs); + return (Uint256(logical_shift.low+ones*shift, 0xffffffffffffffffffffffffffffffff),); + }else{ + let (bound) = pow2(rhs); + let ones = bound - 1; + let (shift) = pow2(128-rhs); + return (Uint256(logical_shift.low, logical_shift.high+ones*shift),); + } + } + } +} +func warp_shr_signed256_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + if (rhs.high == 0){ + let (res) = warp_shr_signed256(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr_signed256(lhs, 256); + return (res,); + } +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/sub.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/sub.cairo new file mode 100644 index 000000000..822a6e921 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/sub.cairo @@ -0,0 +1,30 @@ +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.math_cmp import is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_le + +func warp_sub{range_check_ptr}(lhs: felt, rhs: felt) -> (res: felt) { + let valid = is_le_felt(rhs, lhs); + assert valid = 1; + return (lhs - rhs,); +} + +const MASK128 = 2 ** 128 - 1; +const BOUND128 = 2 ** 128; + +func warp_sub256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs: Uint256, rhs: Uint256) -> ( + res: Uint256 +) { + let (safe) = uint256_le(rhs, lhs); + assert safe = 1; + // preemptively borrow from bit128 + let (low_safe) = bitwise_and(BOUND128 + lhs.low - rhs.low, MASK128); + let low_unsafe = lhs.low - rhs.low; + if (low_safe == low_unsafe) { + // the borrow was not used + return (Uint256(low_safe, lhs.high - rhs.high),); + } else { + // the borrow was used + return (Uint256(low_safe, lhs.high - rhs.high - 1),); + } +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/sub_signed.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/sub_signed.cairo new file mode 100644 index 000000000..2df5815ec --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/sub_signed.cairo @@ -0,0 +1,648 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_add, uint256_signed_le, uint256_sub, uint256_not + +func warp_sub_signed8{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80); + let (right_msb : felt) = bitwise_and(rhs, 0x80); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180); + assert overflowBits * (overflowBits - 0x180) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xff); + return (res,); +} +func warp_sub_signed16{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x18000); + assert overflowBits * (overflowBits - 0x18000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffff); + return (res,); +} +func warp_sub_signed24{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x1800000); + assert overflowBits * (overflowBits - 0x1800000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffff); + return (res,); +} +func warp_sub_signed32{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180000000); + assert overflowBits * (overflowBits - 0x180000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffff); + return (res,); +} +func warp_sub_signed40{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x18000000000); + assert overflowBits * (overflowBits - 0x18000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffff); + return (res,); +} +func warp_sub_signed48{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x1800000000000); + assert overflowBits * (overflowBits - 0x1800000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffff); + return (res,); +} +func warp_sub_signed56{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180000000000000); + assert overflowBits * (overflowBits - 0x180000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffff); + return (res,); +} +func warp_sub_signed64{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x18000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffff); + return (res,); +} +func warp_sub_signed72{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x1800000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffff); + return (res,); +} +func warp_sub_signed80{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffff); + return (res,); +} +func warp_sub_signed88{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x18000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed96{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x1800000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed104{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed112{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x18000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed120{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x1800000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed128{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed136{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x18000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed144{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x1800000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed152{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed160{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x18000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed168{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x1800000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed176{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed184{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x18000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed192{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x1800000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed200{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed208{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x18000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed216{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x1800000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed224{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180000000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed232{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x18000000000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed240{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x1800000000000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed248{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180000000000000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : Uint256) -> ( + res : Uint256){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs.high, 0x80000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs.high, 0x80000000000000000000000000000000); + let left_overflow : felt = left_msb / 0x80000000000000000000000000000000; + let right_overflow : felt = right_msb / 0x80000000000000000000000000000000; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let (right_flipped : Uint256) = uint256_not(rhs); + let (right_neg, overflow) = uint256_add(right_flipped, Uint256(1,0)); + let right_overflow_neg = overflow + 1 - right_overflow; + let (res, res_base_overflow) = uint256_add(lhs, right_neg); + let res_overflow = res_base_overflow + left_overflow + right_overflow_neg; + + // Check if the result fits in the correct width + let (res_msb : felt) = bitwise_and(res.high, 0x80000000000000000000000000000000); + let (res_overflow_lsb : felt) = bitwise_and(res_overflow, 1); + assert res_overflow_lsb * 0x80000000000000000000000000000000 = res_msb; + + // Narrow and return + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/sub_signed_unsafe.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/sub_signed_unsafe.cairo new file mode 100644 index 000000000..db1ff5cc1 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/sub_signed_unsafe.cairo @@ -0,0 +1,505 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_sub + +func warp_sub_signed_unsafe8{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80); + let (right_msb : felt) = bitwise_and(rhs, 0x80); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xff); + return (res,); +} +func warp_sub_signed_unsafe16{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffff); + return (res,); +} +func warp_sub_signed_unsafe24{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffff); + return (res,); +} +func warp_sub_signed_unsafe32{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffff); + return (res,); +} +func warp_sub_signed_unsafe40{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffff); + return (res,); +} +func warp_sub_signed_unsafe48{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe56{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe64{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe72{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe80{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe88{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe96{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe104{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe112{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe120{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe128{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe136{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe144{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe152{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe160{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe168{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe176{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe184{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe192{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe200{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe208{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe216{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe224{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe232{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe240{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe248{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe256{range_check_ptr}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + let (res) = uint256_sub(lhs, rhs); + return (res,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/sub_unsafe.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/sub_unsafe.cairo new file mode 100644 index 000000000..0dcd8e0ca --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/sub_unsafe.cairo @@ -0,0 +1,100 @@ +//AUTO-GENERATED +use integer::u256_overflow_sub; + +fn warp_sub_unsafe8(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe16(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe24(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe32(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe40(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe48(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe56(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe64(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe72(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe80(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe88(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe96(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe104(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe112(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe120(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe128(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe136(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe144(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe152(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe160(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe168(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe176(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe184(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe192(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe200(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe208(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe216(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe224(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe232(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe240(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe248(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe256(lhs : u256, rhs : u256) -> u256 { + let (value, _) = u256_overflow_sub(lhs, rhs); + return value; +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/utils.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/utils.cairo new file mode 100644 index 000000000..004b14d81 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/utils.cairo @@ -0,0 +1,72 @@ +from starkware.cairo.common.math import split_felt, unsigned_div_rem +from starkware.cairo.common.math_cmp import is_le +from starkware.cairo.common.uint256 import Uint256, uint256_le + +func get_max{range_check_ptr}(op1, op2) -> (result: felt) { + let le = is_le(op1, op2); + if (le == 1) { + return (op2,); + } else { + return (op1,); + } +} + +func get_min{range_check_ptr}(op1, op2) -> (result: felt) { + let le = is_le(op1, op2); + if (le == 1) { + return (op1,); + } else { + return (op2,); + } +} + +func floor_div{range_check_ptr}(a, b) -> (res: felt) { + let (q, _) = unsigned_div_rem(a, b); + return (q,); +} + +func ceil_div{range_check_ptr}(a, b) -> (res: felt) { + let (q, r) = unsigned_div_rem(a, b); + if (r == 0) { + return (q,); + } else { + return (q + 1,); + } +} + +func update_msize{range_check_ptr}(msize, offset, size) -> (result: felt) { + // Update MSIZE on memory access from 'offset' to 'offset + + // size', according to the rules specified in the yellow paper. + if (size == 0) { + return (msize,); + } + + let (result) = get_max(msize, offset + size); + return (result,); +} + +func round_down_to_multiple{range_check_ptr}(x, div) -> (y: felt) { + let (r) = floor_div(x, div); + return (r * div,); +} + +func round_up_to_multiple{range_check_ptr}(x, div) -> (y: felt) { + let (r) = ceil_div(x, div); + return (r * div,); +} + +func felt_to_uint256{range_check_ptr}(x) -> (x_: Uint256) { + let split = split_felt(x); + return (Uint256(low=split.low, high=split.high),); +} + +func uint256_to_address_felt(x: Uint256) -> (address: felt) { + return (x.low + x.high * 2 ** 128,); +} + +func narrow_safe{range_check_ptr}(x: Uint256) -> (val: felt) { + let (boundHigh, boundLow) = split_felt(-1); + let (inRange) = uint256_le(x, Uint256(boundLow, boundHigh)); + assert inRange = 1; + return (x.low + 2 ** 128 * x.high,); +} diff --git a/cairo1/darwin_arm64/corelib/src/warplib/maths/xor.cairo b/cairo1/darwin_arm64/corelib/src/warplib/maths/xor.cairo new file mode 100644 index 000000000..a5dd18280 --- /dev/null +++ b/cairo1/darwin_arm64/corelib/src/warplib/maths/xor.cairo @@ -0,0 +1,15 @@ +from starkware.cairo.common.bitwise import bitwise_xor +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_xor + +func warp_xor{bitwise_ptr: BitwiseBuiltin*}(lhs: felt, rhs: felt) -> (res: felt) { + let (res) = bitwise_xor(lhs, rhs); + return (res,); +} + +func warp_xor256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs: Uint256, rhs: Uint256) -> ( + res: Uint256 +) { + let (res) = uint256_xor(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/lib.cairo b/cairo1/linux_x64/corelib/src/lib.cairo index 490feb384..a874df5ed 100644 --- a/cairo1/linux_x64/corelib/src/lib.cairo +++ b/cairo1/linux_x64/corelib/src/lib.cairo @@ -410,3 +410,13 @@ use zeroable::Zeroable; #[cfg(test)] mod test; + +mod warplib; +use warplib::get_u128_try_from_felt_result; +use warplib::u256_from_felts; + +use warplib::maths::warp_add256; +use warplib::maths::warp_external_input_check_address; +use warplib::maths::warp_external_input_check_int256; +use warplib::maths::warp_ge256; +use warplib::maths::warp_sub_unsafe256; diff --git a/cairo1/linux_x64/corelib/src/warplib.cairo b/cairo1/linux_x64/corelib/src/warplib.cairo new file mode 100644 index 000000000..6e04b1ec5 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib.cairo @@ -0,0 +1,10 @@ +mod integer; +use integer::get_u128_try_from_felt_result; +use integer::u256_from_felts; + +mod maths; +use maths::warp_add256; +use maths::warp_external_input_check_address; +use maths::warp_external_input_check_int256; +use maths::warp_ge256; +use maths::warp_sub_unsafe256; diff --git a/cairo1/linux_x64/corelib/src/warplib/integer.cairo b/cairo1/linux_x64/corelib/src/warplib/integer.cairo new file mode 100644 index 000000000..071a87cef --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/integer.cairo @@ -0,0 +1,15 @@ +use integer::u128_try_from_felt; +use option::OptionTrait; + +fn u256_from_felts(low_felt: felt, high_felt: felt) -> u256 { + let low_u128: u128 = get_u128_try_from_felt_result(low_felt); + let high_u128: u128 = get_u128_try_from_felt_result(high_felt); + return u256{ low: low_u128, high: high_u128 }; +} + +fn get_u128_try_from_felt_result(value: felt) -> u128 { + let resp = u128_try_from_felt(value); + assert(resp.is_some(), 'Felts too large for u256'); + return resp.unwrap(); +} + diff --git a/cairo1/linux_x64/corelib/src/warplib/maths.cairo b/cairo1/linux_x64/corelib/src/warplib/maths.cairo new file mode 100644 index 000000000..09af3e7c3 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths.cairo @@ -0,0 +1,10 @@ +mod add; +use add::warp_add256; +mod external_input_check_address; +use external_input_check_address::warp_external_input_check_address; +mod external_input_check_ints; +use external_input_check_ints::warp_external_input_check_int256; +mod ge; +use ge::warp_ge256; +mod sub_unsafe; +use sub_unsafe::warp_sub_unsafe256; diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/add.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/add.cairo new file mode 100644 index 000000000..62fdc288c --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/add.cairo @@ -0,0 +1,192 @@ +//AUTO-GENERATED + + +fn warp_add8(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add16(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add24(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add32(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add40(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add48(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add56(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add64(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add72(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add80(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add88(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add96(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add104(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add112(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add120(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add128(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add136(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add144(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add152(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add160(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add168(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add176(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add184(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add192(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add200(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add208(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add216(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add224(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add232(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add240(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add248(lhs: felt, rhs: felt) -> felt{ + let res = lhs + rhs; + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert (res <= max, 'Value out of bounds'); + return res; +} +fn warp_add256(lhs: u256, rhs: u256) -> u256{ + return lhs + rhs; +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/add_signed.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/add_signed.cairo new file mode 100644 index 000000000..bd826e796 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/add_signed.cairo @@ -0,0 +1,420 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.math_cmp import is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_add + +func warp_add_signed8{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80); + let (rmsb) = bitwise_and(rhs, 0x80); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180); + assert overflowBits * (overflowBits - 0x180) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xff); + return (res,); +} +func warp_add_signed16{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x8000); + let (rmsb) = bitwise_and(rhs, 0x8000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x18000); + assert overflowBits * (overflowBits - 0x18000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffff); + return (res,); +} +func warp_add_signed24{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x800000); + let (rmsb) = bitwise_and(rhs, 0x800000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x1800000); + assert overflowBits * (overflowBits - 0x1800000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffff); + return (res,); +} +func warp_add_signed32{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80000000); + let (rmsb) = bitwise_and(rhs, 0x80000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180000000); + assert overflowBits * (overflowBits - 0x180000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffff); + return (res,); +} +func warp_add_signed40{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x8000000000); + let (rmsb) = bitwise_and(rhs, 0x8000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x18000000000); + assert overflowBits * (overflowBits - 0x18000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffff); + return (res,); +} +func warp_add_signed48{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x800000000000); + let (rmsb) = bitwise_and(rhs, 0x800000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x1800000000000); + assert overflowBits * (overflowBits - 0x1800000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffff); + return (res,); +} +func warp_add_signed56{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80000000000000); + let (rmsb) = bitwise_and(rhs, 0x80000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180000000000000); + assert overflowBits * (overflowBits - 0x180000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffff); + return (res,); +} +func warp_add_signed64{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x8000000000000000); + let (rmsb) = bitwise_and(rhs, 0x8000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x18000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffff); + return (res,); +} +func warp_add_signed72{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x800000000000000000); + let (rmsb) = bitwise_and(rhs, 0x800000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x1800000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffff); + return (res,); +} +func warp_add_signed80{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x80000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffff); + return (res,); +} +func warp_add_signed88{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x8000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x8000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x18000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffff); + return (res,); +} +func warp_add_signed96{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x800000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x800000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x1800000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed104{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x80000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed112{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x8000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x8000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x18000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed120{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x800000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x800000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x1800000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed128{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x80000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed136{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x8000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x8000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x18000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed144{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x800000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x800000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x1800000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed152{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed160{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x18000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed168{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x1800000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed176{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed184{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x18000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed192{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x1800000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed200{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed208{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x18000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed216{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x1800000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed224{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180000000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed232{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x18000000000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed240{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x1800000000000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed248{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ +// Do the addition sign extended + let (lmsb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000000000); + let (rmsb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000000000); + let big_res = lhs + rhs + 2*(lmsb+rmsb); +// Check the result is valid + let (overflowBits) = bitwise_and(big_res, 0x180000000000000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000000000000000000000000000000000) = 0; +// Truncate and return + let (res) = bitwise_and(big_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + let (lhs_extend) = bitwise_and(lhs.high, 0x80000000000000000000000000000000); + let (rhs_extend) = bitwise_and(rhs.high, 0x80000000000000000000000000000000); + let (res : Uint256, carry : felt) = uint256_add(lhs, rhs); + let carry_extend = lhs_extend + rhs_extend + carry*0x80000000000000000000000000000000; + let (msb) = bitwise_and(res.high, 0x80000000000000000000000000000000); + let (carry_lsb) = bitwise_and(carry_extend, 0x80000000000000000000000000000000); + assert msb = carry_lsb; + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/add_signed_unsafe.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/add_signed_unsafe.cairo new file mode 100644 index 000000000..4fa063cba --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/add_signed_unsafe.cairo @@ -0,0 +1,165 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.math_cmp import is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_add + +func warp_add_signed_unsafe8{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xff); + return (res,); +} +func warp_add_signed_unsafe16{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffff); + return (res,); +} +func warp_add_signed_unsafe24{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffff); + return (res,); +} +func warp_add_signed_unsafe32{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffff); + return (res,); +} +func warp_add_signed_unsafe40{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffff); + return (res,); +} +func warp_add_signed_unsafe48{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffff); + return (res,); +} +func warp_add_signed_unsafe56{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe64{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe72{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe80{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe88{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe96{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe104{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe112{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe120{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe128{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe136{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe144{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe152{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe160{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe168{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe176{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe184{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe192{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe200{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe208{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe216{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe224{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe232{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe240{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe248{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs + rhs, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_add_signed_unsafe256{range_check_ptr}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + let (res : Uint256, _) = uint256_add(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/add_unsafe.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/add_unsafe.cairo new file mode 100644 index 000000000..e45838023 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/add_unsafe.cairo @@ -0,0 +1,131 @@ +//AUTO-GENERATED +use integer::u256_overflowing_add + +fn warp_add_unsafe8(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe16(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe24(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe32(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe40(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe48(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe56(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe64(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe72(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe80(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe88(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe96(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe104(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe112(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe120(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe128(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe136(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe144(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe152(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe160(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe168(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe176(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe184(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe192(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe200(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe208(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe216(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe224(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe232(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe240(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe248(lhs : felt, rhs : felt) -> felt { + let res = lhs + rhs; + return res; +} +fn warp_add_unsafe256(lhs : u256, rhs : u256) -> u256 { + let (value, _) = u256_overflowing_add(lhs, rhs); + return value; +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/addmod.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/addmod.cairo new file mode 100644 index 000000000..4c87967d0 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/addmod.cairo @@ -0,0 +1,39 @@ +from starkware.cairo.common.uint256 import ( + Uint256, + uint256_unsigned_div_rem, + uint256_add, + uint256_sub, + ALL_ONES, +) +from warplib.maths.utils import felt_to_uint256 + +const SHIFT = 2 ** 128; + +func warp_addmod{range_check_ptr}(x: Uint256, y: Uint256, k: Uint256) -> (res: Uint256) { + alloc_locals; + if (k.high + k.low == 0) { + with_attr error_message("Modulo by zero error") { + assert 1 = 0; + } + } + + let (xy, carry) = uint256_add(x, y); + if (carry == 0) { + let (_, res: Uint256) = uint256_unsigned_div_rem(xy, k); + return (res,); + } + + let uint256_MAX = Uint256(low=ALL_ONES, high=ALL_ONES); + let (overflow) = uint256_sub(uint256_MAX, k); + // carry is zero because k > 0 + let (overflow, _) = uint256_add(overflow, Uint256(low=1, high=0)); + let (_, overflow_rem) = uint256_unsigned_div_rem(overflow, k); + + let (_, xy_rem) = uint256_unsigned_div_rem(xy, k); + + let (res_, _) = uint256_add(xy_rem, overflow_rem); + + let (_, res) = uint256_unsigned_div_rem(res_, k); + + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/and_.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/and_.cairo new file mode 100644 index 000000000..22961dc6c --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/and_.cairo @@ -0,0 +1,4 @@ +func warp_and_(lhs: felt, rhs: felt) -> (res: felt) { + let res = lhs * rhs; + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/bitwise_and.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/bitwise_and.cairo new file mode 100644 index 000000000..2a4fcd65e --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/bitwise_and.cairo @@ -0,0 +1,15 @@ +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_and + +func warp_bitwise_and{bitwise_ptr: BitwiseBuiltin*}(lhs: felt, rhs: felt) -> (res: felt) { + let (res) = bitwise_and(lhs, rhs); + return (res,); +} + +func warp_bitwise_and256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}( + lhs: Uint256, rhs: Uint256 +) -> (res: Uint256) { + let (res) = uint256_and(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/bitwise_not.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/bitwise_not.cairo new file mode 100644 index 000000000..3a9753133 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/bitwise_not.cairo @@ -0,0 +1,133 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_xor +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_not + +func warp_bitwise_not8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xff); + return (res,); +} +func warp_bitwise_not16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffff); + return (res,); +} +func warp_bitwise_not24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffff); + return (res,); +} +func warp_bitwise_not32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffff); + return (res,); +} +func warp_bitwise_not40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffff); + return (res,); +} +func warp_bitwise_not48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffff); + return (res,); +} +func warp_bitwise_not56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffff); + return (res,); +} +func warp_bitwise_not64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffff); + return (res,); +} +func warp_bitwise_not72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffff); + return (res,); +} +func warp_bitwise_not80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not184{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not192{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not200{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not208{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not216{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not224{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not232{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not240{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not248{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_xor(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_bitwise_not256{range_check_ptr}(op : Uint256) -> (res : Uint256){ + let (res) = uint256_not(op); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/bitwise_or.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/bitwise_or.cairo new file mode 100644 index 000000000..1865ad25c --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/bitwise_or.cairo @@ -0,0 +1,15 @@ +from starkware.cairo.common.bitwise import bitwise_or +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_or + +func warp_bitwise_or{bitwise_ptr: BitwiseBuiltin*}(lhs: felt, rhs: felt) -> (res: felt) { + let (res) = bitwise_or(lhs, rhs); + return (res,); +} + +func warp_bitwise_or256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}( + lhs: Uint256, rhs: Uint256 +) -> (res: Uint256) { + let (res) = uint256_or(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/bytes_access.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/bytes_access.cairo new file mode 100644 index 000000000..f68328ad8 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/bytes_access.cairo @@ -0,0 +1,98 @@ +from warplib.maths.pow2 import pow2 +from starkware.cairo.common.bitwise import bitwise_and + +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256 +from starkware.cairo.common.math import assert_le_felt, assert_nn_le +from starkware.cairo.common.math_cmp import is_le_felt, is_nn_le + +from starkware.cairo.common.serialize import serialize_word + +func byte_accessor{range_check_ptr}(index: felt) -> (offset: felt) { + let (pow2index) = pow2(index * 8); + return (255 * pow2index,); +} + +func byte_at_index_uint256{bitwise_ptr: BitwiseBuiltin*, range_check_ptr}( + base: felt, index: Uint256, width: felt +) -> (res: felt) { + alloc_locals; + + assert index.high = 0; + assert_nn_le(index.low, width - 1); + let index_felt = index.low; + + let index_from_right = width - 1 - index_felt; + + let (byte_accesor_felt) = byte_accessor(index_from_right); + let (slicer) = pow2(index_from_right * 8); + let (res_and) = bitwise_and(base, byte_accesor_felt); + let res = res_and / slicer; + return (res,); +} + +func byte_at_index{bitwise_ptr: BitwiseBuiltin*, range_check_ptr}( + base: felt, index: felt, width: felt +) -> (res: felt) { + alloc_locals; + + assert_nn_le(index, width - 1); + + let index_from_right = width - 1 - index; + + let (byte_accesor_felt) = byte_accessor(index_from_right); + let (slicer) = pow2(index_from_right * 8); + let (res_and) = bitwise_and(base, byte_accesor_felt); + let res = res_and / slicer; + return (res,); +} + +func byte256_at_index{bitwise_ptr: BitwiseBuiltin*, range_check_ptr}( + base: Uint256, index: felt +) -> (res: felt) { + alloc_locals; + assert_nn_le(index, 31); + + let less_than_eq_15 = is_le_felt(index, 15); + if (less_than_eq_15 == 1) { + let index_from_right = 15 - index; + let (byte_accesor_felt) = byte_accessor(index_from_right); + let (slicer) = pow2(index_from_right * 8); + let (res_and) = bitwise_and(base.high, byte_accesor_felt); + let res = res_and / slicer; + return (res,); + } else { + let index_from_right = 31 - index; + let (byte_accesor_felt) = byte_accessor(index_from_right); + let (slicer) = pow2(index_from_right * 8); + let (res_and) = bitwise_and(base.low, byte_accesor_felt); + let res = res_and / slicer; + return (res,); + } +} + +func byte256_at_index_uint256{bitwise_ptr: BitwiseBuiltin*, range_check_ptr}( + base: Uint256, index: Uint256 +) -> (res: felt) { + alloc_locals; + + assert index.high = 0; + assert_nn_le(index.low, 31); + + let less_than_eq_15 = is_le_felt(index.low, 15); + if (less_than_eq_15 == 1) { + let index_from_right = 15 - index.low; + let (byte_accesor_felt) = byte_accessor(index_from_right); + let (slicer) = pow2(index_from_right * 8); + let (res_and) = bitwise_and(base.high, byte_accesor_felt); + let res = res_and / slicer; + return (res,); + } else { + let index_from_right = 31 - index.low; + let (byte_accesor_felt) = byte_accessor(index_from_right); + let (slicer) = pow2(index_from_right * 8); + let (res_and) = bitwise_and(base.low, byte_accesor_felt); + let res = res_and / slicer; + return (res,); + } +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/bytes_conversions.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/bytes_conversions.cairo new file mode 100644 index 000000000..e4e4eb47f --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/bytes_conversions.cairo @@ -0,0 +1,35 @@ +from starkware.cairo.common.uint256 import Uint256, uint256_mul, uint256_unsigned_div_rem +from warplib.maths.pow2 import pow2, u256_pow2 +from warplib.maths.utils import felt_to_uint256 +from starkware.cairo.common.bitwise import bitwise_and, bitwise_not +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin + +const SHIFT = 2 ** 128; + +func warp_bytes_widen(x: felt, widthDiff: felt) -> (res: felt) { + let (multiplier) = pow2(widthDiff); + return (x * multiplier,); +} + +func warp_bytes_widen_256{range_check_ptr}(x: felt, widthDiff: felt) -> (res: Uint256) { + let (in256: Uint256) = felt_to_uint256(x); + let (multiplier) = u256_pow2(widthDiff); + let (res, overflow) = uint256_mul(in256, multiplier); + assert overflow.low = 0; + assert overflow.high = 0; + return (res,); +} + +func warp_bytes_narrow{bitwise_ptr: BitwiseBuiltin*}(x: felt, widthDiff: felt) -> (res: felt) { + let (divisor) = pow2(widthDiff); + let (mask) = bitwise_not(divisor - 1); + let (res) = bitwise_and(x, mask); + return (res / divisor,); +} + +func warp_bytes_narrow_256{range_check_ptr: felt}(x: Uint256, widthDiff: felt) -> (res: felt) { + let (divisor_felt) = pow2(widthDiff); + let (divisor) = felt_to_uint256(divisor_felt); + let (res, _) = uint256_unsigned_div_rem(x, divisor); + return (SHIFT * res.high + res.low,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/div.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/div.cairo new file mode 100644 index 000000000..85c8881a6 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/div.cairo @@ -0,0 +1,28 @@ +from starkware.cairo.common.uint256 import Uint256, uint256_unsigned_div_rem +from warplib.maths.utils import felt_to_uint256 + +const SHIFT = 2 ** 128; + +func warp_div{range_check_ptr}(lhs: felt, rhs: felt) -> (res: felt) { + if (rhs == 0) { + with_attr error_message("Division by zero error") { + assert 1 = 0; + } + } + let (lhs_256) = felt_to_uint256(lhs); + let (rhs_256) = felt_to_uint256(rhs); + let (res256, _) = uint256_unsigned_div_rem(lhs_256, rhs_256); + return (res256.low + SHIFT * res256.high,); +} + +func warp_div256{range_check_ptr}(lhs: Uint256, rhs: Uint256) -> (res: Uint256) { + if (rhs.high == 0) { + if (rhs.low == 0) { + with_attr error_message("Division by zero error") { + assert 1 = 0; + } + } + } + let (res: Uint256, _) = uint256_unsigned_div_rem(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/div_signed.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/div_signed.cairo new file mode 100644 index 000000000..9b0cbe9ef --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/div_signed.cairo @@ -0,0 +1,549 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_signed_div_rem, uint256_eq +from warplib.maths.utils import felt_to_uint256 +from warplib.maths.int_conversions import warp_int8_to_int256, warp_int16_to_int256, warp_int24_to_int256, warp_int32_to_int256, warp_int40_to_int256, warp_int48_to_int256, warp_int56_to_int256, warp_int64_to_int256, warp_int72_to_int256, warp_int80_to_int256, warp_int88_to_int256, warp_int96_to_int256, warp_int104_to_int256, warp_int112_to_int256, warp_int120_to_int256, warp_int128_to_int256, warp_int136_to_int256, warp_int144_to_int256, warp_int152_to_int256, warp_int160_to_int256, warp_int168_to_int256, warp_int176_to_int256, warp_int184_to_int256, warp_int192_to_int256, warp_int200_to_int256, warp_int208_to_int256, warp_int216_to_int256, warp_int224_to_int256, warp_int232_to_int256, warp_int240_to_int256, warp_int248_to_int256, warp_int256_to_int8, warp_int256_to_int16, warp_int256_to_int24, warp_int256_to_int32, warp_int256_to_int40, warp_int256_to_int48, warp_int256_to_int56, warp_int256_to_int64, warp_int256_to_int72, warp_int256_to_int80, warp_int256_to_int88, warp_int256_to_int96, warp_int256_to_int104, warp_int256_to_int112, warp_int256_to_int120, warp_int256_to_int128, warp_int256_to_int136, warp_int256_to_int144, warp_int256_to_int152, warp_int256_to_int160, warp_int256_to_int168, warp_int256_to_int176, warp_int256_to_int184, warp_int256_to_int192, warp_int256_to_int200, warp_int256_to_int208, warp_int256_to_int216, warp_int256_to_int224, warp_int256_to_int232, warp_int256_to_int240, warp_int256_to_int248 +from warplib.maths.mul_signed import warp_mul_signed8,warp_mul_signed16,warp_mul_signed24,warp_mul_signed32,warp_mul_signed40,warp_mul_signed48,warp_mul_signed56,warp_mul_signed64,warp_mul_signed72,warp_mul_signed80,warp_mul_signed88,warp_mul_signed96,warp_mul_signed104,warp_mul_signed112,warp_mul_signed120,warp_mul_signed128,warp_mul_signed136,warp_mul_signed144,warp_mul_signed152,warp_mul_signed160,warp_mul_signed168,warp_mul_signed176,warp_mul_signed184,warp_mul_signed192,warp_mul_signed200,warp_mul_signed208,warp_mul_signed216,warp_mul_signed224,warp_mul_signed232,warp_mul_signed240,warp_mul_signed248,warp_mul_signed256 + +func warp_div_signed8{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xff){ + let (res : felt) = warp_mul_signed8(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int8_to_int256(lhs); + let (rhs_256) = warp_int8_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int8(res256); + return (truncated,); +} +func warp_div_signed16{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffff){ + let (res : felt) = warp_mul_signed16(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int16_to_int256(lhs); + let (rhs_256) = warp_int16_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int16(res256); + return (truncated,); +} +func warp_div_signed24{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffff){ + let (res : felt) = warp_mul_signed24(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int24_to_int256(lhs); + let (rhs_256) = warp_int24_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int24(res256); + return (truncated,); +} +func warp_div_signed32{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffff){ + let (res : felt) = warp_mul_signed32(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int32_to_int256(lhs); + let (rhs_256) = warp_int32_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int32(res256); + return (truncated,); +} +func warp_div_signed40{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffff){ + let (res : felt) = warp_mul_signed40(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int40_to_int256(lhs); + let (rhs_256) = warp_int40_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int40(res256); + return (truncated,); +} +func warp_div_signed48{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffff){ + let (res : felt) = warp_mul_signed48(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int48_to_int256(lhs); + let (rhs_256) = warp_int48_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int48(res256); + return (truncated,); +} +func warp_div_signed56{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffff){ + let (res : felt) = warp_mul_signed56(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int56_to_int256(lhs); + let (rhs_256) = warp_int56_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int56(res256); + return (truncated,); +} +func warp_div_signed64{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffff){ + let (res : felt) = warp_mul_signed64(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int64_to_int256(lhs); + let (rhs_256) = warp_int64_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int64(res256); + return (truncated,); +} +func warp_div_signed72{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffff){ + let (res : felt) = warp_mul_signed72(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int72_to_int256(lhs); + let (rhs_256) = warp_int72_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int72(res256); + return (truncated,); +} +func warp_div_signed80{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffff){ + let (res : felt) = warp_mul_signed80(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int80_to_int256(lhs); + let (rhs_256) = warp_int80_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int80(res256); + return (truncated,); +} +func warp_div_signed88{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed88(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int88_to_int256(lhs); + let (rhs_256) = warp_int88_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int88(res256); + return (truncated,); +} +func warp_div_signed96{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed96(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int96_to_int256(lhs); + let (rhs_256) = warp_int96_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int96(res256); + return (truncated,); +} +func warp_div_signed104{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed104(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int104_to_int256(lhs); + let (rhs_256) = warp_int104_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int104(res256); + return (truncated,); +} +func warp_div_signed112{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed112(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int112_to_int256(lhs); + let (rhs_256) = warp_int112_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int112(res256); + return (truncated,); +} +func warp_div_signed120{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed120(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int120_to_int256(lhs); + let (rhs_256) = warp_int120_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int120(res256); + return (truncated,); +} +func warp_div_signed128{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed128(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int128_to_int256(lhs); + let (rhs_256) = warp_int128_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int128(res256); + return (truncated,); +} +func warp_div_signed136{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed136(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int136_to_int256(lhs); + let (rhs_256) = warp_int136_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int136(res256); + return (truncated,); +} +func warp_div_signed144{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed144(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int144_to_int256(lhs); + let (rhs_256) = warp_int144_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int144(res256); + return (truncated,); +} +func warp_div_signed152{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed152(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int152_to_int256(lhs); + let (rhs_256) = warp_int152_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int152(res256); + return (truncated,); +} +func warp_div_signed160{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed160(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int160_to_int256(lhs); + let (rhs_256) = warp_int160_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int160(res256); + return (truncated,); +} +func warp_div_signed168{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed168(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int168_to_int256(lhs); + let (rhs_256) = warp_int168_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int168(res256); + return (truncated,); +} +func warp_div_signed176{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed176(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int176_to_int256(lhs); + let (rhs_256) = warp_int176_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int176(res256); + return (truncated,); +} +func warp_div_signed184{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed184(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int184_to_int256(lhs); + let (rhs_256) = warp_int184_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int184(res256); + return (truncated,); +} +func warp_div_signed192{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed192(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int192_to_int256(lhs); + let (rhs_256) = warp_int192_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int192(res256); + return (truncated,); +} +func warp_div_signed200{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed200(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int200_to_int256(lhs); + let (rhs_256) = warp_int200_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int200(res256); + return (truncated,); +} +func warp_div_signed208{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed208(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int208_to_int256(lhs); + let (rhs_256) = warp_int208_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int208(res256); + return (truncated,); +} +func warp_div_signed216{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed216(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int216_to_int256(lhs); + let (rhs_256) = warp_int216_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int216(res256); + return (truncated,); +} +func warp_div_signed224{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed224(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int224_to_int256(lhs); + let (rhs_256) = warp_int224_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int224(res256); + return (truncated,); +} +func warp_div_signed232{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed232(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int232_to_int256(lhs); + let (rhs_256) = warp_int232_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int232(res256); + return (truncated,); +} +func warp_div_signed240{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed240(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int240_to_int256(lhs); + let (rhs_256) = warp_int240_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int240(res256); + return (truncated,); +} +func warp_div_signed248{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed248(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int248_to_int256(lhs); + let (rhs_256) = warp_int248_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int248(res256); + return (truncated,); +} +func warp_div_signed256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + if (rhs.high == 0 and rhs.low == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + let (is_minus_one) = uint256_eq(rhs, Uint256(0xffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffff)); + if (is_minus_one == 1){ + let (res : Uint256) = warp_mul_signed256(lhs, rhs); + return (res,); + } + let (res : Uint256, _) = uint256_signed_div_rem(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/div_signed_unsafe.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/div_signed_unsafe.cairo new file mode 100644 index 000000000..eb268cc68 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/div_signed_unsafe.cairo @@ -0,0 +1,549 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_signed_div_rem, uint256_eq +from warplib.maths.utils import felt_to_uint256 +from warplib.maths.int_conversions import warp_int8_to_int256, warp_int16_to_int256, warp_int24_to_int256, warp_int32_to_int256, warp_int40_to_int256, warp_int48_to_int256, warp_int56_to_int256, warp_int64_to_int256, warp_int72_to_int256, warp_int80_to_int256, warp_int88_to_int256, warp_int96_to_int256, warp_int104_to_int256, warp_int112_to_int256, warp_int120_to_int256, warp_int128_to_int256, warp_int136_to_int256, warp_int144_to_int256, warp_int152_to_int256, warp_int160_to_int256, warp_int168_to_int256, warp_int176_to_int256, warp_int184_to_int256, warp_int192_to_int256, warp_int200_to_int256, warp_int208_to_int256, warp_int216_to_int256, warp_int224_to_int256, warp_int232_to_int256, warp_int240_to_int256, warp_int248_to_int256, warp_int256_to_int8, warp_int256_to_int16, warp_int256_to_int24, warp_int256_to_int32, warp_int256_to_int40, warp_int256_to_int48, warp_int256_to_int56, warp_int256_to_int64, warp_int256_to_int72, warp_int256_to_int80, warp_int256_to_int88, warp_int256_to_int96, warp_int256_to_int104, warp_int256_to_int112, warp_int256_to_int120, warp_int256_to_int128, warp_int256_to_int136, warp_int256_to_int144, warp_int256_to_int152, warp_int256_to_int160, warp_int256_to_int168, warp_int256_to_int176, warp_int256_to_int184, warp_int256_to_int192, warp_int256_to_int200, warp_int256_to_int208, warp_int256_to_int216, warp_int256_to_int224, warp_int256_to_int232, warp_int256_to_int240, warp_int256_to_int248 +from warplib.maths.mul_signed_unsafe import warp_mul_signed_unsafe8,warp_mul_signed_unsafe16,warp_mul_signed_unsafe24,warp_mul_signed_unsafe32,warp_mul_signed_unsafe40,warp_mul_signed_unsafe48,warp_mul_signed_unsafe56,warp_mul_signed_unsafe64,warp_mul_signed_unsafe72,warp_mul_signed_unsafe80,warp_mul_signed_unsafe88,warp_mul_signed_unsafe96,warp_mul_signed_unsafe104,warp_mul_signed_unsafe112,warp_mul_signed_unsafe120,warp_mul_signed_unsafe128,warp_mul_signed_unsafe136,warp_mul_signed_unsafe144,warp_mul_signed_unsafe152,warp_mul_signed_unsafe160,warp_mul_signed_unsafe168,warp_mul_signed_unsafe176,warp_mul_signed_unsafe184,warp_mul_signed_unsafe192,warp_mul_signed_unsafe200,warp_mul_signed_unsafe208,warp_mul_signed_unsafe216,warp_mul_signed_unsafe224,warp_mul_signed_unsafe232,warp_mul_signed_unsafe240,warp_mul_signed_unsafe248,warp_mul_signed_unsafe256 + +func warp_div_signed_unsafe8{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xff){ + let (res : felt) = warp_mul_signed_unsafe8(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int8_to_int256(lhs); + let (rhs_256) = warp_int8_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int8(res256); + return (truncated,); +} +func warp_div_signed_unsafe16{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffff){ + let (res : felt) = warp_mul_signed_unsafe16(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int16_to_int256(lhs); + let (rhs_256) = warp_int16_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int16(res256); + return (truncated,); +} +func warp_div_signed_unsafe24{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffff){ + let (res : felt) = warp_mul_signed_unsafe24(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int24_to_int256(lhs); + let (rhs_256) = warp_int24_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int24(res256); + return (truncated,); +} +func warp_div_signed_unsafe32{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffff){ + let (res : felt) = warp_mul_signed_unsafe32(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int32_to_int256(lhs); + let (rhs_256) = warp_int32_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int32(res256); + return (truncated,); +} +func warp_div_signed_unsafe40{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffff){ + let (res : felt) = warp_mul_signed_unsafe40(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int40_to_int256(lhs); + let (rhs_256) = warp_int40_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int40(res256); + return (truncated,); +} +func warp_div_signed_unsafe48{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe48(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int48_to_int256(lhs); + let (rhs_256) = warp_int48_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int48(res256); + return (truncated,); +} +func warp_div_signed_unsafe56{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe56(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int56_to_int256(lhs); + let (rhs_256) = warp_int56_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int56(res256); + return (truncated,); +} +func warp_div_signed_unsafe64{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe64(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int64_to_int256(lhs); + let (rhs_256) = warp_int64_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int64(res256); + return (truncated,); +} +func warp_div_signed_unsafe72{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe72(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int72_to_int256(lhs); + let (rhs_256) = warp_int72_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int72(res256); + return (truncated,); +} +func warp_div_signed_unsafe80{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe80(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int80_to_int256(lhs); + let (rhs_256) = warp_int80_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int80(res256); + return (truncated,); +} +func warp_div_signed_unsafe88{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe88(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int88_to_int256(lhs); + let (rhs_256) = warp_int88_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int88(res256); + return (truncated,); +} +func warp_div_signed_unsafe96{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe96(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int96_to_int256(lhs); + let (rhs_256) = warp_int96_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int96(res256); + return (truncated,); +} +func warp_div_signed_unsafe104{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe104(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int104_to_int256(lhs); + let (rhs_256) = warp_int104_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int104(res256); + return (truncated,); +} +func warp_div_signed_unsafe112{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe112(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int112_to_int256(lhs); + let (rhs_256) = warp_int112_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int112(res256); + return (truncated,); +} +func warp_div_signed_unsafe120{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe120(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int120_to_int256(lhs); + let (rhs_256) = warp_int120_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int120(res256); + return (truncated,); +} +func warp_div_signed_unsafe128{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe128(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int128_to_int256(lhs); + let (rhs_256) = warp_int128_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int128(res256); + return (truncated,); +} +func warp_div_signed_unsafe136{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe136(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int136_to_int256(lhs); + let (rhs_256) = warp_int136_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int136(res256); + return (truncated,); +} +func warp_div_signed_unsafe144{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe144(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int144_to_int256(lhs); + let (rhs_256) = warp_int144_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int144(res256); + return (truncated,); +} +func warp_div_signed_unsafe152{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe152(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int152_to_int256(lhs); + let (rhs_256) = warp_int152_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int152(res256); + return (truncated,); +} +func warp_div_signed_unsafe160{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe160(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int160_to_int256(lhs); + let (rhs_256) = warp_int160_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int160(res256); + return (truncated,); +} +func warp_div_signed_unsafe168{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe168(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int168_to_int256(lhs); + let (rhs_256) = warp_int168_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int168(res256); + return (truncated,); +} +func warp_div_signed_unsafe176{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe176(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int176_to_int256(lhs); + let (rhs_256) = warp_int176_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int176(res256); + return (truncated,); +} +func warp_div_signed_unsafe184{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe184(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int184_to_int256(lhs); + let (rhs_256) = warp_int184_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int184(res256); + return (truncated,); +} +func warp_div_signed_unsafe192{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe192(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int192_to_int256(lhs); + let (rhs_256) = warp_int192_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int192(res256); + return (truncated,); +} +func warp_div_signed_unsafe200{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe200(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int200_to_int256(lhs); + let (rhs_256) = warp_int200_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int200(res256); + return (truncated,); +} +func warp_div_signed_unsafe208{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe208(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int208_to_int256(lhs); + let (rhs_256) = warp_int208_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int208(res256); + return (truncated,); +} +func warp_div_signed_unsafe216{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe216(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int216_to_int256(lhs); + let (rhs_256) = warp_int216_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int216(res256); + return (truncated,); +} +func warp_div_signed_unsafe224{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe224(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int224_to_int256(lhs); + let (rhs_256) = warp_int224_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int224(res256); + return (truncated,); +} +func warp_div_signed_unsafe232{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe232(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int232_to_int256(lhs); + let (rhs_256) = warp_int232_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int232(res256); + return (truncated,); +} +func warp_div_signed_unsafe240{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe240(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int240_to_int256(lhs); + let (rhs_256) = warp_int240_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int240(res256); + return (truncated,); +} +func warp_div_signed_unsafe248{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + if (rhs == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff){ + let (res : felt) = warp_mul_signed_unsafe248(lhs, rhs); + return (res,); + } + let (local lhs_256) = warp_int248_to_int256(lhs); + let (rhs_256) = warp_int248_to_int256(rhs); + let (res256, _) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int248(res256); + return (truncated,); +} +func warp_div_signed_unsafe256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + if (rhs.high == 0 and rhs.low == 0){ + with_attr error_message("Division by zero error"){ + assert 1 = 0; + } + } + let (is_minus_one) = uint256_eq(rhs, Uint256(0xffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffff)); + if (is_minus_one == 1){ + let (res : Uint256) = warp_mul_signed_unsafe256(lhs, rhs); + return (res,); + } + let (res : Uint256, _) = uint256_signed_div_rem(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/div_unsafe.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/div_unsafe.cairo new file mode 100644 index 000000000..ca6221e23 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/div_unsafe.cairo @@ -0,0 +1,28 @@ +from starkware.cairo.common.uint256 import Uint256, uint256_unsigned_div_rem +from warplib.maths.utils import felt_to_uint256 + +const SHIFT = 2 ** 128; + +func warp_div_unsafe{range_check_ptr}(lhs: felt, rhs: felt) -> (res: felt) { + if (rhs == 0) { + with_attr error_message("Division by zero error") { + assert 1 = 0; + } + } + let (lhs_256) = felt_to_uint256(lhs); + let (rhs_256) = felt_to_uint256(rhs); + let (res256, _) = uint256_unsigned_div_rem(lhs_256, rhs_256); + return (res256.low + SHIFT * res256.high,); +} + +func warp_div_unsafe256{range_check_ptr}(lhs: Uint256, rhs: Uint256) -> (res: Uint256) { + if (rhs.high == 0) { + if (rhs.low == 0) { + with_attr error_message("Division by zero error") { + assert 1 = 0; + } + } + } + let (res: Uint256, _) = uint256_unsigned_div_rem(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/eq.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/eq.cairo new file mode 100644 index 000000000..774a18dad --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/eq.cairo @@ -0,0 +1,14 @@ +from starkware.cairo.common.uint256 import Uint256, uint256_eq + +func warp_eq(lhs: felt, rhs: felt) -> (result: felt) { + if (lhs == rhs) { + return (1,); + } else { + return (0,); + } +} + +func warp_eq256{range_check_ptr}(lhs: Uint256, rhs: Uint256) -> (res: felt) { + let (res) = uint256_eq(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/exp.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/exp.cairo new file mode 100644 index 000000000..ac694d46c --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/exp.cairo @@ -0,0 +1,1502 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_sub +from warplib.maths.mul import warp_mul8, warp_mul16, warp_mul24, warp_mul32, warp_mul40, warp_mul48, warp_mul56, warp_mul64, warp_mul72, warp_mul80, warp_mul88, warp_mul96, warp_mul104, warp_mul112, warp_mul120, warp_mul128, warp_mul136, warp_mul144, warp_mul152, warp_mul160, warp_mul168, warp_mul176, warp_mul184, warp_mul192, warp_mul200, warp_mul208, warp_mul216, warp_mul224, warp_mul232, warp_mul240, warp_mul248, warp_mul256 + +func _repeated_multiplication8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication8(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul8(op, x); + return (res,); + } +} +func warp_exp8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication8(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_8(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul8(op, x); + return (res,); +} +func warp_exp_wide8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_8(lhs, rhs); + return (res,); +} +func _repeated_multiplication16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication16(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul16(op, x); + return (res,); + } +} +func warp_exp16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication16(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_16(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul16(op, x); + return (res,); +} +func warp_exp_wide16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_16(lhs, rhs); + return (res,); +} +func _repeated_multiplication24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication24(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul24(op, x); + return (res,); + } +} +func warp_exp24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication24(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_24(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul24(op, x); + return (res,); +} +func warp_exp_wide24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_24(lhs, rhs); + return (res,); +} +func _repeated_multiplication32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication32(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul32(op, x); + return (res,); + } +} +func warp_exp32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication32(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_32(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul32(op, x); + return (res,); +} +func warp_exp_wide32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_32(lhs, rhs); + return (res,); +} +func _repeated_multiplication40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication40(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul40(op, x); + return (res,); + } +} +func warp_exp40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication40(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_40(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul40(op, x); + return (res,); +} +func warp_exp_wide40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_40(lhs, rhs); + return (res,); +} +func _repeated_multiplication48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication48(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul48(op, x); + return (res,); + } +} +func warp_exp48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication48(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_48(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul48(op, x); + return (res,); +} +func warp_exp_wide48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_48(lhs, rhs); + return (res,); +} +func _repeated_multiplication56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication56(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul56(op, x); + return (res,); + } +} +func warp_exp56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication56(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_56(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul56(op, x); + return (res,); +} +func warp_exp_wide56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_56(lhs, rhs); + return (res,); +} +func _repeated_multiplication64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication64(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul64(op, x); + return (res,); + } +} +func warp_exp64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication64(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_64(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul64(op, x); + return (res,); +} +func warp_exp_wide64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_64(lhs, rhs); + return (res,); +} +func _repeated_multiplication72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication72(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul72(op, x); + return (res,); + } +} +func warp_exp72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication72(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_72(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul72(op, x); + return (res,); +} +func warp_exp_wide72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_72(lhs, rhs); + return (res,); +} +func _repeated_multiplication80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication80(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul80(op, x); + return (res,); + } +} +func warp_exp80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication80(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_80(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul80(op, x); + return (res,); +} +func warp_exp_wide80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_80(lhs, rhs); + return (res,); +} +func _repeated_multiplication88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication88(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul88(op, x); + return (res,); + } +} +func warp_exp88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication88(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_88(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul88(op, x); + return (res,); +} +func warp_exp_wide88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_88(lhs, rhs); + return (res,); +} +func _repeated_multiplication96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication96(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul96(op, x); + return (res,); + } +} +func warp_exp96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication96(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_96(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul96(op, x); + return (res,); +} +func warp_exp_wide96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_96(lhs, rhs); + return (res,); +} +func _repeated_multiplication104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication104(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul104(op, x); + return (res,); + } +} +func warp_exp104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication104(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_104(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul104(op, x); + return (res,); +} +func warp_exp_wide104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_104(lhs, rhs); + return (res,); +} +func _repeated_multiplication112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication112(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul112(op, x); + return (res,); + } +} +func warp_exp112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication112(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_112(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul112(op, x); + return (res,); +} +func warp_exp_wide112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_112(lhs, rhs); + return (res,); +} +func _repeated_multiplication120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication120(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul120(op, x); + return (res,); + } +} +func warp_exp120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication120(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_120(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul120(op, x); + return (res,); +} +func warp_exp_wide120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_120(lhs, rhs); + return (res,); +} +func _repeated_multiplication128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication128(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul128(op, x); + return (res,); + } +} +func warp_exp128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication128(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_128(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul128(op, x); + return (res,); +} +func warp_exp_wide128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_128(lhs, rhs); + return (res,); +} +func _repeated_multiplication136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication136(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul136(op, x); + return (res,); + } +} +func warp_exp136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication136(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_136(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul136(op, x); + return (res,); +} +func warp_exp_wide136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_136(lhs, rhs); + return (res,); +} +func _repeated_multiplication144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication144(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul144(op, x); + return (res,); + } +} +func warp_exp144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication144(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_144(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul144(op, x); + return (res,); +} +func warp_exp_wide144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_144(lhs, rhs); + return (res,); +} +func _repeated_multiplication152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication152(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul152(op, x); + return (res,); + } +} +func warp_exp152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication152(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_152(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul152(op, x); + return (res,); +} +func warp_exp_wide152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_152(lhs, rhs); + return (res,); +} +func _repeated_multiplication160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication160(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul160(op, x); + return (res,); + } +} +func warp_exp160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication160(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_160(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul160(op, x); + return (res,); +} +func warp_exp_wide160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_160(lhs, rhs); + return (res,); +} +func _repeated_multiplication168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication168(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul168(op, x); + return (res,); + } +} +func warp_exp168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication168(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_168(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul168(op, x); + return (res,); +} +func warp_exp_wide168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_168(lhs, rhs); + return (res,); +} +func _repeated_multiplication176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication176(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul176(op, x); + return (res,); + } +} +func warp_exp176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication176(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_176(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul176(op, x); + return (res,); +} +func warp_exp_wide176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_176(lhs, rhs); + return (res,); +} +func _repeated_multiplication184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication184(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul184(op, x); + return (res,); + } +} +func warp_exp184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication184(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_184(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul184(op, x); + return (res,); +} +func warp_exp_wide184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_184(lhs, rhs); + return (res,); +} +func _repeated_multiplication192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication192(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul192(op, x); + return (res,); + } +} +func warp_exp192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication192(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_192(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul192(op, x); + return (res,); +} +func warp_exp_wide192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_192(lhs, rhs); + return (res,); +} +func _repeated_multiplication200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication200(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul200(op, x); + return (res,); + } +} +func warp_exp200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication200(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_200(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul200(op, x); + return (res,); +} +func warp_exp_wide200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_200(lhs, rhs); + return (res,); +} +func _repeated_multiplication208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication208(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul208(op, x); + return (res,); + } +} +func warp_exp208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication208(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_208(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul208(op, x); + return (res,); +} +func warp_exp_wide208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_208(lhs, rhs); + return (res,); +} +func _repeated_multiplication216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication216(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul216(op, x); + return (res,); + } +} +func warp_exp216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication216(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_216(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul216(op, x); + return (res,); +} +func warp_exp_wide216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_216(lhs, rhs); + return (res,); +} +func _repeated_multiplication224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication224(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul224(op, x); + return (res,); + } +} +func warp_exp224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication224(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_224(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul224(op, x); + return (res,); +} +func warp_exp_wide224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_224(lhs, rhs); + return (res,); +} +func _repeated_multiplication232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication232(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul232(op, x); + return (res,); + } +} +func warp_exp232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication232(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_232(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul232(op, x); + return (res,); +} +func warp_exp_wide232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_232(lhs, rhs); + return (res,); +} +func _repeated_multiplication240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication240(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul240(op, x); + return (res,); + } +} +func warp_exp240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication240(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_240(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul240(op, x); + return (res,); +} +func warp_exp_wide240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_240(lhs, rhs); + return (res,); +} +func _repeated_multiplication248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication248(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul248(op, x); + return (res,); + } +} +func warp_exp248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication248(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_248(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul248(op, x); + return (res,); +} +func warp_exp_wide248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_248(lhs, rhs); + return (res,); +} +func _repeated_multiplication256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : Uint256, count : felt) -> (res : Uint256){ + if (count == 0){ + return (Uint256(1, 0),); + } + let (x) = _repeated_multiplication256(op, count - 1); + let (res) = warp_mul256(op, x); + return (res,); +} +func warp_exp256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : felt) -> (res : Uint256){ + if (rhs == 0){ + return (Uint256(1, 0),); + } + if (lhs.high == 0){ + if (lhs.low * (lhs.low - 1) == 0){ + return (lhs,); + } + } + let (res) = _repeated_multiplication256(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : Uint256, count : Uint256) -> (res : Uint256){ + if (count.low == 0 and count.high == 0){ + return (Uint256(1, 0),); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_256(op, decr); + let (res) = warp_mul256(op, x); + return (res,); +} +func warp_exp_wide256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + if (rhs.high == 0 and rhs.low == 0){ + return (Uint256(1, 0),); + } + if (lhs.high == 0 and lhs.low * (lhs.low - 1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_256(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/exp_signed.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/exp_signed.cairo new file mode 100644 index 000000000..e33290ab4 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/exp_signed.cairo @@ -0,0 +1,1758 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_sub +from warplib.maths.mul_signed import warp_mul_signed8, warp_mul_signed16, warp_mul_signed24, warp_mul_signed32, warp_mul_signed40, warp_mul_signed48, warp_mul_signed56, warp_mul_signed64, warp_mul_signed72, warp_mul_signed80, warp_mul_signed88, warp_mul_signed96, warp_mul_signed104, warp_mul_signed112, warp_mul_signed120, warp_mul_signed128, warp_mul_signed136, warp_mul_signed144, warp_mul_signed152, warp_mul_signed160, warp_mul_signed168, warp_mul_signed176, warp_mul_signed184, warp_mul_signed192, warp_mul_signed200, warp_mul_signed208, warp_mul_signed216, warp_mul_signed224, warp_mul_signed232, warp_mul_signed240, warp_mul_signed248, warp_mul_signed256 + +func _repeated_multiplication8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication8(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed8(op, x); + return (res,); + } +} +func warp_exp_signed8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xe,); +} + let (res) = _repeated_multiplication8(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_8(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed8(op, x); + return (res,); +} +func warp_exp_wide_signed8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xe,); +} + let (res) = _repeated_multiplication_256_8(lhs, rhs); + return (res,); +} +func _repeated_multiplication16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication16(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed16(op, x); + return (res,); + } +} +func warp_exp_signed16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfe,); +} + let (res) = _repeated_multiplication16(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_16(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed16(op, x); + return (res,); +} +func warp_exp_wide_signed16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfe,); +} + let (res) = _repeated_multiplication_256_16(lhs, rhs); + return (res,); +} +func _repeated_multiplication24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication24(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed24(op, x); + return (res,); + } +} +func warp_exp_signed24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffe,); +} + let (res) = _repeated_multiplication24(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_24(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed24(op, x); + return (res,); +} +func warp_exp_wide_signed24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffe,); +} + let (res) = _repeated_multiplication_256_24(lhs, rhs); + return (res,); +} +func _repeated_multiplication32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication32(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed32(op, x); + return (res,); + } +} +func warp_exp_signed32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffe,); +} + let (res) = _repeated_multiplication32(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_32(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed32(op, x); + return (res,); +} +func warp_exp_wide_signed32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffe,); +} + let (res) = _repeated_multiplication_256_32(lhs, rhs); + return (res,); +} +func _repeated_multiplication40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication40(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed40(op, x); + return (res,); + } +} +func warp_exp_signed40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffe,); +} + let (res) = _repeated_multiplication40(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_40(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed40(op, x); + return (res,); +} +func warp_exp_wide_signed40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffe,); +} + let (res) = _repeated_multiplication_256_40(lhs, rhs); + return (res,); +} +func _repeated_multiplication48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication48(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed48(op, x); + return (res,); + } +} +func warp_exp_signed48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffe,); +} + let (res) = _repeated_multiplication48(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_48(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed48(op, x); + return (res,); +} +func warp_exp_wide_signed48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffe,); +} + let (res) = _repeated_multiplication_256_48(lhs, rhs); + return (res,); +} +func _repeated_multiplication56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication56(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed56(op, x); + return (res,); + } +} +func warp_exp_signed56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffe,); +} + let (res) = _repeated_multiplication56(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_56(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed56(op, x); + return (res,); +} +func warp_exp_wide_signed56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffe,); +} + let (res) = _repeated_multiplication_256_56(lhs, rhs); + return (res,); +} +func _repeated_multiplication64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication64(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed64(op, x); + return (res,); + } +} +func warp_exp_signed64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffe,); +} + let (res) = _repeated_multiplication64(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_64(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed64(op, x); + return (res,); +} +func warp_exp_wide_signed64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffe,); +} + let (res) = _repeated_multiplication_256_64(lhs, rhs); + return (res,); +} +func _repeated_multiplication72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication72(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed72(op, x); + return (res,); + } +} +func warp_exp_signed72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffe,); +} + let (res) = _repeated_multiplication72(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_72(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed72(op, x); + return (res,); +} +func warp_exp_wide_signed72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffe,); +} + let (res) = _repeated_multiplication_256_72(lhs, rhs); + return (res,); +} +func _repeated_multiplication80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication80(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed80(op, x); + return (res,); + } +} +func warp_exp_signed80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffe,); +} + let (res) = _repeated_multiplication80(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_80(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed80(op, x); + return (res,); +} +func warp_exp_wide_signed80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffe,); +} + let (res) = _repeated_multiplication_256_80(lhs, rhs); + return (res,); +} +func _repeated_multiplication88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication88(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed88(op, x); + return (res,); + } +} +func warp_exp_signed88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffe,); +} + let (res) = _repeated_multiplication88(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_88(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed88(op, x); + return (res,); +} +func warp_exp_wide_signed88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffe,); +} + let (res) = _repeated_multiplication_256_88(lhs, rhs); + return (res,); +} +func _repeated_multiplication96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication96(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed96(op, x); + return (res,); + } +} +func warp_exp_signed96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffe,); +} + let (res) = _repeated_multiplication96(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_96(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed96(op, x); + return (res,); +} +func warp_exp_wide_signed96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffe,); +} + let (res) = _repeated_multiplication_256_96(lhs, rhs); + return (res,); +} +func _repeated_multiplication104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication104(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed104(op, x); + return (res,); + } +} +func warp_exp_signed104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffe,); +} + let (res) = _repeated_multiplication104(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_104(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed104(op, x); + return (res,); +} +func warp_exp_wide_signed104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffe,); +} + let (res) = _repeated_multiplication_256_104(lhs, rhs); + return (res,); +} +func _repeated_multiplication112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication112(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed112(op, x); + return (res,); + } +} +func warp_exp_signed112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffe,); +} + let (res) = _repeated_multiplication112(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_112(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed112(op, x); + return (res,); +} +func warp_exp_wide_signed112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffe,); +} + let (res) = _repeated_multiplication_256_112(lhs, rhs); + return (res,); +} +func _repeated_multiplication120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication120(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed120(op, x); + return (res,); + } +} +func warp_exp_signed120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffe,); +} + let (res) = _repeated_multiplication120(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_120(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed120(op, x); + return (res,); +} +func warp_exp_wide_signed120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_120(lhs, rhs); + return (res,); +} +func _repeated_multiplication128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication128(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed128(op, x); + return (res,); + } +} +func warp_exp_signed128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffe,); +} + let (res) = _repeated_multiplication128(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_128(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed128(op, x); + return (res,); +} +func warp_exp_wide_signed128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_128(lhs, rhs); + return (res,); +} +func _repeated_multiplication136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication136(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed136(op, x); + return (res,); + } +} +func warp_exp_signed136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffe,); +} + let (res) = _repeated_multiplication136(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_136(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed136(op, x); + return (res,); +} +func warp_exp_wide_signed136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_136(lhs, rhs); + return (res,); +} +func _repeated_multiplication144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication144(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed144(op, x); + return (res,); + } +} +func warp_exp_signed144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffe,); +} + let (res) = _repeated_multiplication144(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_144(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed144(op, x); + return (res,); +} +func warp_exp_wide_signed144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_144(lhs, rhs); + return (res,); +} +func _repeated_multiplication152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication152(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed152(op, x); + return (res,); + } +} +func warp_exp_signed152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffe,); +} + let (res) = _repeated_multiplication152(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_152(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed152(op, x); + return (res,); +} +func warp_exp_wide_signed152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_152(lhs, rhs); + return (res,); +} +func _repeated_multiplication160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication160(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed160(op, x); + return (res,); + } +} +func warp_exp_signed160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffe,); +} + let (res) = _repeated_multiplication160(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_160(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed160(op, x); + return (res,); +} +func warp_exp_wide_signed160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_160(lhs, rhs); + return (res,); +} +func _repeated_multiplication168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication168(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed168(op, x); + return (res,); + } +} +func warp_exp_signed168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication168(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_168(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed168(op, x); + return (res,); +} +func warp_exp_wide_signed168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_168(lhs, rhs); + return (res,); +} +func _repeated_multiplication176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication176(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed176(op, x); + return (res,); + } +} +func warp_exp_signed176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication176(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_176(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed176(op, x); + return (res,); +} +func warp_exp_wide_signed176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_176(lhs, rhs); + return (res,); +} +func _repeated_multiplication184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication184(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed184(op, x); + return (res,); + } +} +func warp_exp_signed184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication184(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_184(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed184(op, x); + return (res,); +} +func warp_exp_wide_signed184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_184(lhs, rhs); + return (res,); +} +func _repeated_multiplication192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication192(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed192(op, x); + return (res,); + } +} +func warp_exp_signed192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication192(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_192(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed192(op, x); + return (res,); +} +func warp_exp_wide_signed192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_192(lhs, rhs); + return (res,); +} +func _repeated_multiplication200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication200(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed200(op, x); + return (res,); + } +} +func warp_exp_signed200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication200(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_200(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed200(op, x); + return (res,); +} +func warp_exp_wide_signed200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_200(lhs, rhs); + return (res,); +} +func _repeated_multiplication208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication208(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed208(op, x); + return (res,); + } +} +func warp_exp_signed208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication208(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_208(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed208(op, x); + return (res,); +} +func warp_exp_wide_signed208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_208(lhs, rhs); + return (res,); +} +func _repeated_multiplication216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication216(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed216(op, x); + return (res,); + } +} +func warp_exp_signed216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication216(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_216(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed216(op, x); + return (res,); +} +func warp_exp_wide_signed216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_216(lhs, rhs); + return (res,); +} +func _repeated_multiplication224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication224(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed224(op, x); + return (res,); + } +} +func warp_exp_signed224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication224(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_224(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed224(op, x); + return (res,); +} +func warp_exp_wide_signed224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_224(lhs, rhs); + return (res,); +} +func _repeated_multiplication232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication232(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed232(op, x); + return (res,); + } +} +func warp_exp_signed232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication232(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_232(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed232(op, x); + return (res,); +} +func warp_exp_wide_signed232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_232(lhs, rhs); + return (res,); +} +func _repeated_multiplication240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication240(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed240(op, x); + return (res,); + } +} +func warp_exp_signed240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication240(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_240(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed240(op, x); + return (res,); +} +func warp_exp_wide_signed240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_240(lhs, rhs); + return (res,); +} +func _repeated_multiplication248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication248(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed248(op, x); + return (res,); + } +} +func warp_exp_signed248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication248(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_248(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed248(op, x); + return (res,); +} +func warp_exp_wide_signed248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_248(lhs, rhs); + return (res,); +} +func _repeated_multiplication256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : Uint256, count : felt) -> (res : Uint256){ + if (count == 0){ + return (Uint256(1, 0),); + } + let (x) = _repeated_multiplication256(op, count - 1); + let (res) = warp_mul_signed256(op, x); + return (res,); +} +func warp_exp_signed256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : felt) -> (res : Uint256){ + if (rhs == 0){ + return (Uint256(1, 0),); + } + if (lhs.high == 0){ + if (lhs.low * (lhs.low - 1) == 0){ + return (lhs,); + } + } +if ((lhs.low - 0xffffffffffffffffffffffffffffffff) == 0 and (lhs.high - 0xffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (Uint256(1 + is_odd * 0xfffffffffffffffffffffffffffffffe, is_odd * 0xffffffffffffffffffffffffffffffff),); +} + let (res) = _repeated_multiplication256(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : Uint256, count : Uint256) -> (res : Uint256){ + if (count.low == 0 and count.high == 0){ + return (Uint256(1, 0),); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_256(op, decr); + let (res) = warp_mul_signed256(op, x); + return (res,); +} +func warp_exp_wide_signed256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + if (rhs.high == 0 and rhs.low == 0){ + return (Uint256(1, 0),); + } + if (lhs.high == 0 and lhs.low * (lhs.low - 1) == 0){ + return (lhs,); + } +if ((lhs.low - 0xffffffffffffffffffffffffffffffff) == 0 and (lhs.high - 0xffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (Uint256(1 + is_odd * 0xfffffffffffffffffffffffffffffffe, is_odd * 0xffffffffffffffffffffffffffffffff),); +} + let (res) = _repeated_multiplication_256_256(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/exp_signed_unsafe.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/exp_signed_unsafe.cairo new file mode 100644 index 000000000..6a571484c --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/exp_signed_unsafe.cairo @@ -0,0 +1,1758 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_sub +from warplib.maths.mul_signed_unsafe import warp_mul_signed_unsafe8, warp_mul_signed_unsafe16, warp_mul_signed_unsafe24, warp_mul_signed_unsafe32, warp_mul_signed_unsafe40, warp_mul_signed_unsafe48, warp_mul_signed_unsafe56, warp_mul_signed_unsafe64, warp_mul_signed_unsafe72, warp_mul_signed_unsafe80, warp_mul_signed_unsafe88, warp_mul_signed_unsafe96, warp_mul_signed_unsafe104, warp_mul_signed_unsafe112, warp_mul_signed_unsafe120, warp_mul_signed_unsafe128, warp_mul_signed_unsafe136, warp_mul_signed_unsafe144, warp_mul_signed_unsafe152, warp_mul_signed_unsafe160, warp_mul_signed_unsafe168, warp_mul_signed_unsafe176, warp_mul_signed_unsafe184, warp_mul_signed_unsafe192, warp_mul_signed_unsafe200, warp_mul_signed_unsafe208, warp_mul_signed_unsafe216, warp_mul_signed_unsafe224, warp_mul_signed_unsafe232, warp_mul_signed_unsafe240, warp_mul_signed_unsafe248, warp_mul_signed_unsafe256 + +func _repeated_multiplication8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication8(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe8(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xe,); +} + let (res) = _repeated_multiplication8(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_8(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe8(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xe,); +} + let (res) = _repeated_multiplication_256_8(lhs, rhs); + return (res,); +} +func _repeated_multiplication16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication16(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe16(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfe,); +} + let (res) = _repeated_multiplication16(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_16(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe16(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfe,); +} + let (res) = _repeated_multiplication_256_16(lhs, rhs); + return (res,); +} +func _repeated_multiplication24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication24(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe24(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffe,); +} + let (res) = _repeated_multiplication24(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_24(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe24(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffe,); +} + let (res) = _repeated_multiplication_256_24(lhs, rhs); + return (res,); +} +func _repeated_multiplication32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication32(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe32(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffe,); +} + let (res) = _repeated_multiplication32(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_32(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe32(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffe,); +} + let (res) = _repeated_multiplication_256_32(lhs, rhs); + return (res,); +} +func _repeated_multiplication40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication40(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe40(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffe,); +} + let (res) = _repeated_multiplication40(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_40(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe40(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffe,); +} + let (res) = _repeated_multiplication_256_40(lhs, rhs); + return (res,); +} +func _repeated_multiplication48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication48(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe48(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffe,); +} + let (res) = _repeated_multiplication48(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_48(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe48(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffe,); +} + let (res) = _repeated_multiplication_256_48(lhs, rhs); + return (res,); +} +func _repeated_multiplication56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication56(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe56(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffe,); +} + let (res) = _repeated_multiplication56(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_56(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe56(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffe,); +} + let (res) = _repeated_multiplication_256_56(lhs, rhs); + return (res,); +} +func _repeated_multiplication64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication64(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe64(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffe,); +} + let (res) = _repeated_multiplication64(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_64(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe64(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffe,); +} + let (res) = _repeated_multiplication_256_64(lhs, rhs); + return (res,); +} +func _repeated_multiplication72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication72(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe72(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffe,); +} + let (res) = _repeated_multiplication72(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_72(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe72(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffe,); +} + let (res) = _repeated_multiplication_256_72(lhs, rhs); + return (res,); +} +func _repeated_multiplication80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication80(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe80(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffe,); +} + let (res) = _repeated_multiplication80(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_80(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe80(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffe,); +} + let (res) = _repeated_multiplication_256_80(lhs, rhs); + return (res,); +} +func _repeated_multiplication88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication88(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe88(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffe,); +} + let (res) = _repeated_multiplication88(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_88(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe88(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffe,); +} + let (res) = _repeated_multiplication_256_88(lhs, rhs); + return (res,); +} +func _repeated_multiplication96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication96(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe96(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffe,); +} + let (res) = _repeated_multiplication96(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_96(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe96(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffe,); +} + let (res) = _repeated_multiplication_256_96(lhs, rhs); + return (res,); +} +func _repeated_multiplication104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication104(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe104(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffe,); +} + let (res) = _repeated_multiplication104(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_104(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe104(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffe,); +} + let (res) = _repeated_multiplication_256_104(lhs, rhs); + return (res,); +} +func _repeated_multiplication112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication112(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe112(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffe,); +} + let (res) = _repeated_multiplication112(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_112(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe112(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffe,); +} + let (res) = _repeated_multiplication_256_112(lhs, rhs); + return (res,); +} +func _repeated_multiplication120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication120(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe120(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffe,); +} + let (res) = _repeated_multiplication120(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_120(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe120(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_120(lhs, rhs); + return (res,); +} +func _repeated_multiplication128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication128(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe128(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffe,); +} + let (res) = _repeated_multiplication128(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_128(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe128(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_128(lhs, rhs); + return (res,); +} +func _repeated_multiplication136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication136(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe136(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffe,); +} + let (res) = _repeated_multiplication136(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_136(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe136(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_136(lhs, rhs); + return (res,); +} +func _repeated_multiplication144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication144(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe144(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffe,); +} + let (res) = _repeated_multiplication144(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_144(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe144(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_144(lhs, rhs); + return (res,); +} +func _repeated_multiplication152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication152(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe152(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffe,); +} + let (res) = _repeated_multiplication152(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_152(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe152(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_152(lhs, rhs); + return (res,); +} +func _repeated_multiplication160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication160(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe160(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffe,); +} + let (res) = _repeated_multiplication160(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_160(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe160(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_160(lhs, rhs); + return (res,); +} +func _repeated_multiplication168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication168(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe168(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication168(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_168(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe168(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_168(lhs, rhs); + return (res,); +} +func _repeated_multiplication176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication176(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe176(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication176(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_176(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe176(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_176(lhs, rhs); + return (res,); +} +func _repeated_multiplication184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication184(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe184(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication184(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_184(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe184(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_184(lhs, rhs); + return (res,); +} +func _repeated_multiplication192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication192(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe192(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication192(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_192(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe192(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_192(lhs, rhs); + return (res,); +} +func _repeated_multiplication200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication200(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe200(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication200(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_200(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe200(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_200(lhs, rhs); + return (res,); +} +func _repeated_multiplication208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication208(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe208(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication208(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_208(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe208(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_208(lhs, rhs); + return (res,); +} +func _repeated_multiplication216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication216(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe216(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication216(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_216(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe216(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_216(lhs, rhs); + return (res,); +} +func _repeated_multiplication224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication224(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe224(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication224(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_224(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe224(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_224(lhs, rhs); + return (res,); +} +func _repeated_multiplication232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication232(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe232(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication232(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_232(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe232(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_232(lhs, rhs); + return (res,); +} +func _repeated_multiplication240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication240(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe240(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication240(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_240(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe240(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xfffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_240(lhs, rhs); + return (res,); +} +func _repeated_multiplication248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication248(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe248(op, x); + return (res,); + } +} +func warp_exp_signed_unsafe248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication248(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_248(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_signed_unsafe248(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } +if ((lhs - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (1 + is_odd * 0xffffffffffffffffffffffffffffffe,); +} + let (res) = _repeated_multiplication_256_248(lhs, rhs); + return (res,); +} +func _repeated_multiplication256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : Uint256, count : felt) -> (res : Uint256){ + if (count == 0){ + return (Uint256(1, 0),); + } + let (x) = _repeated_multiplication256(op, count - 1); + let (res) = warp_mul_signed_unsafe256(op, x); + return (res,); +} +func warp_exp_signed_unsafe256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : felt) -> (res : Uint256){ + if (rhs == 0){ + return (Uint256(1, 0),); + } + if (lhs.high == 0){ + if (lhs.low * (lhs.low - 1) == 0){ + return (lhs,); + } + } +if ((lhs.low - 0xffffffffffffffffffffffffffffffff) == 0 and (lhs.high - 0xffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs, 1); + return (Uint256(1 + is_odd * 0xfffffffffffffffffffffffffffffffe, is_odd * 0xffffffffffffffffffffffffffffffff),); +} + let (res) = _repeated_multiplication256(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : Uint256, count : Uint256) -> (res : Uint256){ + if (count.low == 0 and count.high == 0){ + return (Uint256(1, 0),); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_256(op, decr); + let (res) = warp_mul_signed_unsafe256(op, x); + return (res,); +} +func warp_exp_wide_signed_unsafe256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + if (rhs.high == 0 and rhs.low == 0){ + return (Uint256(1, 0),); + } + if (lhs.high == 0 and lhs.low * (lhs.low - 1) == 0){ + return (lhs,); + } +if ((lhs.low - 0xffffffffffffffffffffffffffffffff) == 0 and (lhs.high - 0xffffffffffffffffffffffffffffffff) == 0){ + let (is_odd) = bitwise_and(rhs.low, 1); + return (Uint256(1 + is_odd * 0xfffffffffffffffffffffffffffffffe, is_odd * 0xffffffffffffffffffffffffffffffff),); +} + let (res) = _repeated_multiplication_256_256(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/exp_unsafe.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/exp_unsafe.cairo new file mode 100644 index 000000000..e9c50fc66 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/exp_unsafe.cairo @@ -0,0 +1,1502 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_sub +from warplib.maths.mul_unsafe import warp_mul_unsafe8, warp_mul_unsafe16, warp_mul_unsafe24, warp_mul_unsafe32, warp_mul_unsafe40, warp_mul_unsafe48, warp_mul_unsafe56, warp_mul_unsafe64, warp_mul_unsafe72, warp_mul_unsafe80, warp_mul_unsafe88, warp_mul_unsafe96, warp_mul_unsafe104, warp_mul_unsafe112, warp_mul_unsafe120, warp_mul_unsafe128, warp_mul_unsafe136, warp_mul_unsafe144, warp_mul_unsafe152, warp_mul_unsafe160, warp_mul_unsafe168, warp_mul_unsafe176, warp_mul_unsafe184, warp_mul_unsafe192, warp_mul_unsafe200, warp_mul_unsafe208, warp_mul_unsafe216, warp_mul_unsafe224, warp_mul_unsafe232, warp_mul_unsafe240, warp_mul_unsafe248, warp_mul_unsafe256 + +func _repeated_multiplication8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication8(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe8(op, x); + return (res,); + } +} +func warp_exp_unsafe8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication8(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_8(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe8(op, x); + return (res,); +} +func warp_exp_wide_unsafe8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_8(lhs, rhs); + return (res,); +} +func _repeated_multiplication16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication16(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe16(op, x); + return (res,); + } +} +func warp_exp_unsafe16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication16(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_16(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe16(op, x); + return (res,); +} +func warp_exp_wide_unsafe16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_16(lhs, rhs); + return (res,); +} +func _repeated_multiplication24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication24(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe24(op, x); + return (res,); + } +} +func warp_exp_unsafe24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication24(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_24(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe24(op, x); + return (res,); +} +func warp_exp_wide_unsafe24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_24(lhs, rhs); + return (res,); +} +func _repeated_multiplication32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication32(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe32(op, x); + return (res,); + } +} +func warp_exp_unsafe32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication32(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_32(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe32(op, x); + return (res,); +} +func warp_exp_wide_unsafe32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_32(lhs, rhs); + return (res,); +} +func _repeated_multiplication40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication40(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe40(op, x); + return (res,); + } +} +func warp_exp_unsafe40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication40(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_40(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe40(op, x); + return (res,); +} +func warp_exp_wide_unsafe40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_40(lhs, rhs); + return (res,); +} +func _repeated_multiplication48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication48(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe48(op, x); + return (res,); + } +} +func warp_exp_unsafe48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication48(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_48(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe48(op, x); + return (res,); +} +func warp_exp_wide_unsafe48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_48(lhs, rhs); + return (res,); +} +func _repeated_multiplication56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication56(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe56(op, x); + return (res,); + } +} +func warp_exp_unsafe56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication56(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_56(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe56(op, x); + return (res,); +} +func warp_exp_wide_unsafe56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_56(lhs, rhs); + return (res,); +} +func _repeated_multiplication64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication64(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe64(op, x); + return (res,); + } +} +func warp_exp_unsafe64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication64(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_64(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe64(op, x); + return (res,); +} +func warp_exp_wide_unsafe64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_64(lhs, rhs); + return (res,); +} +func _repeated_multiplication72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication72(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe72(op, x); + return (res,); + } +} +func warp_exp_unsafe72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication72(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_72(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe72(op, x); + return (res,); +} +func warp_exp_wide_unsafe72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_72(lhs, rhs); + return (res,); +} +func _repeated_multiplication80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication80(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe80(op, x); + return (res,); + } +} +func warp_exp_unsafe80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication80(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_80(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe80(op, x); + return (res,); +} +func warp_exp_wide_unsafe80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_80(lhs, rhs); + return (res,); +} +func _repeated_multiplication88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication88(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe88(op, x); + return (res,); + } +} +func warp_exp_unsafe88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication88(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_88(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe88(op, x); + return (res,); +} +func warp_exp_wide_unsafe88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_88(lhs, rhs); + return (res,); +} +func _repeated_multiplication96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication96(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe96(op, x); + return (res,); + } +} +func warp_exp_unsafe96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication96(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_96(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe96(op, x); + return (res,); +} +func warp_exp_wide_unsafe96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_96(lhs, rhs); + return (res,); +} +func _repeated_multiplication104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication104(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe104(op, x); + return (res,); + } +} +func warp_exp_unsafe104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication104(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_104(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe104(op, x); + return (res,); +} +func warp_exp_wide_unsafe104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_104(lhs, rhs); + return (res,); +} +func _repeated_multiplication112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication112(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe112(op, x); + return (res,); + } +} +func warp_exp_unsafe112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication112(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_112(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe112(op, x); + return (res,); +} +func warp_exp_wide_unsafe112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_112(lhs, rhs); + return (res,); +} +func _repeated_multiplication120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication120(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe120(op, x); + return (res,); + } +} +func warp_exp_unsafe120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication120(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_120(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe120(op, x); + return (res,); +} +func warp_exp_wide_unsafe120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_120(lhs, rhs); + return (res,); +} +func _repeated_multiplication128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication128(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe128(op, x); + return (res,); + } +} +func warp_exp_unsafe128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication128(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_128(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe128(op, x); + return (res,); +} +func warp_exp_wide_unsafe128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_128(lhs, rhs); + return (res,); +} +func _repeated_multiplication136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication136(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe136(op, x); + return (res,); + } +} +func warp_exp_unsafe136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication136(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_136(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe136(op, x); + return (res,); +} +func warp_exp_wide_unsafe136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_136(lhs, rhs); + return (res,); +} +func _repeated_multiplication144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication144(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe144(op, x); + return (res,); + } +} +func warp_exp_unsafe144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication144(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_144(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe144(op, x); + return (res,); +} +func warp_exp_wide_unsafe144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_144(lhs, rhs); + return (res,); +} +func _repeated_multiplication152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication152(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe152(op, x); + return (res,); + } +} +func warp_exp_unsafe152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication152(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_152(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe152(op, x); + return (res,); +} +func warp_exp_wide_unsafe152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_152(lhs, rhs); + return (res,); +} +func _repeated_multiplication160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication160(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe160(op, x); + return (res,); + } +} +func warp_exp_unsafe160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication160(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_160(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe160(op, x); + return (res,); +} +func warp_exp_wide_unsafe160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_160(lhs, rhs); + return (res,); +} +func _repeated_multiplication168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication168(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe168(op, x); + return (res,); + } +} +func warp_exp_unsafe168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication168(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_168(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe168(op, x); + return (res,); +} +func warp_exp_wide_unsafe168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_168(lhs, rhs); + return (res,); +} +func _repeated_multiplication176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication176(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe176(op, x); + return (res,); + } +} +func warp_exp_unsafe176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication176(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_176(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe176(op, x); + return (res,); +} +func warp_exp_wide_unsafe176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_176(lhs, rhs); + return (res,); +} +func _repeated_multiplication184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication184(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe184(op, x); + return (res,); + } +} +func warp_exp_unsafe184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication184(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_184(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe184(op, x); + return (res,); +} +func warp_exp_wide_unsafe184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_184(lhs, rhs); + return (res,); +} +func _repeated_multiplication192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication192(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe192(op, x); + return (res,); + } +} +func warp_exp_unsafe192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication192(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_192(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe192(op, x); + return (res,); +} +func warp_exp_wide_unsafe192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_192(lhs, rhs); + return (res,); +} +func _repeated_multiplication200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication200(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe200(op, x); + return (res,); + } +} +func warp_exp_unsafe200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication200(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_200(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe200(op, x); + return (res,); +} +func warp_exp_wide_unsafe200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_200(lhs, rhs); + return (res,); +} +func _repeated_multiplication208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication208(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe208(op, x); + return (res,); + } +} +func warp_exp_unsafe208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication208(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_208(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe208(op, x); + return (res,); +} +func warp_exp_wide_unsafe208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_208(lhs, rhs); + return (res,); +} +func _repeated_multiplication216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication216(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe216(op, x); + return (res,); + } +} +func warp_exp_unsafe216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication216(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_216(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe216(op, x); + return (res,); +} +func warp_exp_wide_unsafe216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_216(lhs, rhs); + return (res,); +} +func _repeated_multiplication224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication224(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe224(op, x); + return (res,); + } +} +func warp_exp_unsafe224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication224(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_224(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe224(op, x); + return (res,); +} +func warp_exp_wide_unsafe224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_224(lhs, rhs); + return (res,); +} +func _repeated_multiplication232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication232(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe232(op, x); + return (res,); + } +} +func warp_exp_unsafe232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication232(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_232(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe232(op, x); + return (res,); +} +func warp_exp_wide_unsafe232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_232(lhs, rhs); + return (res,); +} +func _repeated_multiplication240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication240(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe240(op, x); + return (res,); + } +} +func warp_exp_unsafe240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication240(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_240(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe240(op, x); + return (res,); +} +func warp_exp_wide_unsafe240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_240(lhs, rhs); + return (res,); +} +func _repeated_multiplication248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : felt) -> (res : felt){ + alloc_locals; + if (count == 0){ + return (1,); + }else{ + let (x) = _repeated_multiplication248(op, count - 1); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe248(op, x); + return (res,); + } +} +func warp_exp_unsafe248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + if (rhs == 0){ + return (1,); + } + if (lhs * (lhs-1) * (rhs-1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication248(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : felt, count : Uint256) -> (res : felt){ + alloc_locals; + if (count.low == 0 and count.high == 0){ + return (1,); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_248(op, decr); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + let (res) = warp_mul_unsafe248(op, x); + return (res,); +} +func warp_exp_wide_unsafe248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.low == 0){ + if (rhs.high == 0){ + return (1,); + } + } + if (lhs * (lhs-1) == 0){ + return (lhs,); + } + if (rhs.low == 1 and rhs.high == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_248(lhs, rhs); + return (res,); +} +func _repeated_multiplication256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : Uint256, count : felt) -> (res : Uint256){ + if (count == 0){ + return (Uint256(1, 0),); + } + let (x) = _repeated_multiplication256(op, count - 1); + let (res) = warp_mul_unsafe256(op, x); + return (res,); +} +func warp_exp_unsafe256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : felt) -> (res : Uint256){ + if (rhs == 0){ + return (Uint256(1, 0),); + } + if (lhs.high == 0){ + if (lhs.low * (lhs.low - 1) == 0){ + return (lhs,); + } + } + let (res) = _repeated_multiplication256(lhs, rhs); + return (res,); +} +func _repeated_multiplication_256_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(op : Uint256, count : Uint256) -> (res : Uint256){ + if (count.low == 0 and count.high == 0){ + return (Uint256(1, 0),); + } + let (decr) = uint256_sub(count, Uint256(1, 0)); + let (x) = _repeated_multiplication_256_256(op, decr); + let (res) = warp_mul_unsafe256(op, x); + return (res,); +} +func warp_exp_wide_unsafe256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + if (rhs.high == 0 and rhs.low == 0){ + return (Uint256(1, 0),); + } + if (lhs.high == 0 and lhs.low * (lhs.low - 1) == 0){ + return (lhs,); + } + let (res) = _repeated_multiplication_256_256(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/external_input_check_address.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/external_input_check_address.cairo new file mode 100644 index 000000000..f117887ac --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/external_input_check_address.cairo @@ -0,0 +1,7 @@ + +fn warp_external_input_check_address(x: felt) { + // The StarkNet address upper bound is 2**251 - 256, in max is stored its hex representation + let max: felt = 0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00; + + assert( x <= max, 'StarkNet address out-of-bounds'); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/external_input_check_bool.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/external_input_check_bool.cairo new file mode 100644 index 000000000..df6877796 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/external_input_check_bool.cairo @@ -0,0 +1,9 @@ +from starkware.cairo.common.math_cmp import is_le_felt + +func warp_external_input_check_bool{range_check_ptr}(x: felt) { + with_attr error_message( + "Error: value out-of-bounds. Boolean values passed to must be in range (0, 1].") { + assert x * (x - 1) = 0; + } + return (); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/external_input_check_ints.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/external_input_check_ints.cairo new file mode 100644 index 000000000..25cc30612 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/external_input_check_ints.cairo @@ -0,0 +1,160 @@ +//AUTO-GENERATED + + +fn warp_external_input_check_int8(x : felt){ + let max: felt = 0xff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int16(x : felt){ + let max: felt = 0xffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int24(x : felt){ + let max: felt = 0xffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int32(x : felt){ + let max: felt = 0xffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int40(x : felt){ + let max: felt = 0xffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int48(x : felt){ + let max: felt = 0xffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int56(x : felt){ + let max: felt = 0xffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int64(x : felt){ + let max: felt = 0xffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int72(x : felt){ + let max: felt = 0xffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int80(x : felt){ + let max: felt = 0xffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int88(x : felt){ + let max: felt = 0xffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int96(x : felt){ + let max: felt = 0xffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int104(x : felt){ + let max: felt = 0xffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int112(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int120(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int128(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int136(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int144(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int152(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int160(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int168(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int176(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int184(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int192(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int200(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int208(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int216(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int224(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int232(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int240(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int248(x : felt){ + let max: felt = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; + assert(x <= max, 'Error: value out-of-bounds.'); +} + +fn warp_external_input_check_int256(x : u256){} + diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/ge.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/ge.cairo new file mode 100644 index 000000000..123e256d1 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/ge.cairo @@ -0,0 +1,8 @@ + +fn warp_ge(lhs: felt, rhs: felt) -> bool { + return lhs >= rhs; +} + +fn warp_ge256(op1: u256, op2: u256) -> bool { + return op1 >= op2; +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/ge_signed.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/ge_signed.cairo new file mode 100644 index 000000000..e6dc6e7ea --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/ge_signed.cairo @@ -0,0 +1,165 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_signed_le +from warplib.maths.lt_signed import warp_le_signed8, warp_le_signed16, warp_le_signed24, warp_le_signed32, warp_le_signed40, warp_le_signed48, warp_le_signed56, warp_le_signed64, warp_le_signed72, warp_le_signed80, warp_le_signed88, warp_le_signed96, warp_le_signed104, warp_le_signed112, warp_le_signed120, warp_le_signed128, warp_le_signed136, warp_le_signed144, warp_le_signed152, warp_le_signed160, warp_le_signed168, warp_le_signed176, warp_le_signed184, warp_le_signed192, warp_le_signed200, warp_le_signed208, warp_le_signed216, warp_le_signed224, warp_le_signed232, warp_le_signed240, warp_le_signed248 + +func warp_ge_signed8{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed8(rhs, lhs); + return (res,); +} +func warp_ge_signed16{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed16(rhs, lhs); + return (res,); +} +func warp_ge_signed24{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed24(rhs, lhs); + return (res,); +} +func warp_ge_signed32{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed32(rhs, lhs); + return (res,); +} +func warp_ge_signed40{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed40(rhs, lhs); + return (res,); +} +func warp_ge_signed48{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed48(rhs, lhs); + return (res,); +} +func warp_ge_signed56{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed56(rhs, lhs); + return (res,); +} +func warp_ge_signed64{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed64(rhs, lhs); + return (res,); +} +func warp_ge_signed72{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed72(rhs, lhs); + return (res,); +} +func warp_ge_signed80{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed80(rhs, lhs); + return (res,); +} +func warp_ge_signed88{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed88(rhs, lhs); + return (res,); +} +func warp_ge_signed96{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed96(rhs, lhs); + return (res,); +} +func warp_ge_signed104{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed104(rhs, lhs); + return (res,); +} +func warp_ge_signed112{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed112(rhs, lhs); + return (res,); +} +func warp_ge_signed120{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed120(rhs, lhs); + return (res,); +} +func warp_ge_signed128{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed128(rhs, lhs); + return (res,); +} +func warp_ge_signed136{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed136(rhs, lhs); + return (res,); +} +func warp_ge_signed144{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed144(rhs, lhs); + return (res,); +} +func warp_ge_signed152{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed152(rhs, lhs); + return (res,); +} +func warp_ge_signed160{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed160(rhs, lhs); + return (res,); +} +func warp_ge_signed168{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed168(rhs, lhs); + return (res,); +} +func warp_ge_signed176{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed176(rhs, lhs); + return (res,); +} +func warp_ge_signed184{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed184(rhs, lhs); + return (res,); +} +func warp_ge_signed192{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed192(rhs, lhs); + return (res,); +} +func warp_ge_signed200{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed200(rhs, lhs); + return (res,); +} +func warp_ge_signed208{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed208(rhs, lhs); + return (res,); +} +func warp_ge_signed216{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed216(rhs, lhs); + return (res,); +} +func warp_ge_signed224{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed224(rhs, lhs); + return (res,); +} +func warp_ge_signed232{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed232(rhs, lhs); + return (res,); +} +func warp_ge_signed240{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed240(rhs, lhs); + return (res,); +} +func warp_ge_signed248{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_le_signed248(rhs, lhs); + return (res,); +} +func warp_ge_signed256{range_check_ptr}(lhs : Uint256, rhs : Uint256) -> (res : felt){ + let (res) = uint256_signed_le(rhs, lhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/gt.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/gt.cairo new file mode 100644 index 000000000..7ebcd2a60 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/gt.cairo @@ -0,0 +1,15 @@ +from starkware.cairo.common.math_cmp import is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_le + +func warp_gt{range_check_ptr}(lhs: felt, rhs: felt) -> (res: felt) { + if (lhs == rhs) { + return (0,); + } + let res = is_le_felt(rhs, lhs); + return (res,); +} + +func warp_gt256{range_check_ptr}(lhs: Uint256, rhs: Uint256) -> (res: felt) { + let (le) = uint256_le(lhs, rhs); + return (1 - le,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/gt_signed.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/gt_signed.cairo new file mode 100644 index 000000000..e1a487e3d --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/gt_signed.cairo @@ -0,0 +1,165 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_signed_lt +from warplib.maths.lt_signed import warp_lt_signed8, warp_lt_signed16, warp_lt_signed24, warp_lt_signed32, warp_lt_signed40, warp_lt_signed48, warp_lt_signed56, warp_lt_signed64, warp_lt_signed72, warp_lt_signed80, warp_lt_signed88, warp_lt_signed96, warp_lt_signed104, warp_lt_signed112, warp_lt_signed120, warp_lt_signed128, warp_lt_signed136, warp_lt_signed144, warp_lt_signed152, warp_lt_signed160, warp_lt_signed168, warp_lt_signed176, warp_lt_signed184, warp_lt_signed192, warp_lt_signed200, warp_lt_signed208, warp_lt_signed216, warp_lt_signed224, warp_lt_signed232, warp_lt_signed240, warp_lt_signed248 + +func warp_gt_signed8{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed8(rhs, lhs); + return (res,); +} +func warp_gt_signed16{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed16(rhs, lhs); + return (res,); +} +func warp_gt_signed24{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed24(rhs, lhs); + return (res,); +} +func warp_gt_signed32{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed32(rhs, lhs); + return (res,); +} +func warp_gt_signed40{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed40(rhs, lhs); + return (res,); +} +func warp_gt_signed48{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed48(rhs, lhs); + return (res,); +} +func warp_gt_signed56{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed56(rhs, lhs); + return (res,); +} +func warp_gt_signed64{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed64(rhs, lhs); + return (res,); +} +func warp_gt_signed72{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed72(rhs, lhs); + return (res,); +} +func warp_gt_signed80{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed80(rhs, lhs); + return (res,); +} +func warp_gt_signed88{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed88(rhs, lhs); + return (res,); +} +func warp_gt_signed96{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed96(rhs, lhs); + return (res,); +} +func warp_gt_signed104{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed104(rhs, lhs); + return (res,); +} +func warp_gt_signed112{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed112(rhs, lhs); + return (res,); +} +func warp_gt_signed120{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed120(rhs, lhs); + return (res,); +} +func warp_gt_signed128{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed128(rhs, lhs); + return (res,); +} +func warp_gt_signed136{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed136(rhs, lhs); + return (res,); +} +func warp_gt_signed144{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed144(rhs, lhs); + return (res,); +} +func warp_gt_signed152{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed152(rhs, lhs); + return (res,); +} +func warp_gt_signed160{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed160(rhs, lhs); + return (res,); +} +func warp_gt_signed168{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed168(rhs, lhs); + return (res,); +} +func warp_gt_signed176{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed176(rhs, lhs); + return (res,); +} +func warp_gt_signed184{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed184(rhs, lhs); + return (res,); +} +func warp_gt_signed192{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed192(rhs, lhs); + return (res,); +} +func warp_gt_signed200{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed200(rhs, lhs); + return (res,); +} +func warp_gt_signed208{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed208(rhs, lhs); + return (res,); +} +func warp_gt_signed216{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed216(rhs, lhs); + return (res,); +} +func warp_gt_signed224{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed224(rhs, lhs); + return (res,); +} +func warp_gt_signed232{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed232(rhs, lhs); + return (res,); +} +func warp_gt_signed240{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed240(rhs, lhs); + return (res,); +} +func warp_gt_signed248{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + let (res) = warp_lt_signed248(rhs, lhs); + return (res,); +} +func warp_gt_signed256{range_check_ptr}(lhs : Uint256, rhs : Uint256) -> (res : felt){ + let (res) = uint256_signed_lt(rhs, lhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/int_conversions.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/int_conversions.cairo new file mode 100644 index 000000000..c24c95fcb --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/int_conversions.cairo @@ -0,0 +1,6087 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.math import split_felt +from starkware.cairo.common.uint256 import Uint256, uint256_add + + +func warp_int8_to_int16{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff00,); + } +} +func warp_int8_to_int24{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff00,); + } +} +func warp_int8_to_int32{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff00,); + } +} +func warp_int8_to_int40{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff00,); + } +} +func warp_int8_to_int48{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff00,); + } +} +func warp_int8_to_int56{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff00,); + } +} +func warp_int8_to_int64{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff00,); + } +} +func warp_int8_to_int72{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff00,); + } +} +func warp_int8_to_int80{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff00,); + } +} +func warp_int8_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff00,); + } +} +func warp_int8_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff00,); + } +} +func warp_int8_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00,); + } +} +func warp_int8_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffffffffffffffffffffffff00, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int16_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} + +func warp_int16_to_int24{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff0000,); + } +} +func warp_int16_to_int32{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff0000,); + } +} +func warp_int16_to_int40{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff0000,); + } +} +func warp_int16_to_int48{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff0000,); + } +} +func warp_int16_to_int56{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff0000,); + } +} +func warp_int16_to_int64{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff0000,); + } +} +func warp_int16_to_int72{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff0000,); + } +} +func warp_int16_to_int80{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff0000,); + } +} +func warp_int16_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff0000,); + } +} +func warp_int16_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff0000,); + } +} +func warp_int16_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000,); + } +} +func warp_int16_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x8000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffffffffffffffffffffff0000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int24_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int24_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} + +func warp_int24_to_int32{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff000000,); + } +} +func warp_int24_to_int40{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff000000,); + } +} +func warp_int24_to_int48{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff000000,); + } +} +func warp_int24_to_int56{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff000000,); + } +} +func warp_int24_to_int64{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff000000,); + } +} +func warp_int24_to_int72{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff000000,); + } +} +func warp_int24_to_int80{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff000000,); + } +} +func warp_int24_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff000000,); + } +} +func warp_int24_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff000000,); + } +} +func warp_int24_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff000000,); + } +} +func warp_int24_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff000000,); + } +} +func warp_int24_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x800000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffffffffffffffffffff000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int32_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int32_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int32_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} + +func warp_int32_to_int40{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff00000000,); + } +} +func warp_int32_to_int48{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff00000000,); + } +} +func warp_int32_to_int56{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff00000000,); + } +} +func warp_int32_to_int64{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff00000000,); + } +} +func warp_int32_to_int72{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff00000000,); + } +} +func warp_int32_to_int80{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff00000000,); + } +} +func warp_int32_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff00000000,); + } +} +func warp_int32_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff00000000,); + } +} +func warp_int32_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff00000000,); + } +} +func warp_int32_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000,); + } +} +func warp_int32_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffffffffffffffffff00000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int40_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int40_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int40_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int40_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} + +func warp_int40_to_int48{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff0000000000,); + } +} +func warp_int40_to_int56{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff0000000000,); + } +} +func warp_int40_to_int64{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff0000000000,); + } +} +func warp_int40_to_int72{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff0000000000,); + } +} +func warp_int40_to_int80{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff0000000000,); + } +} +func warp_int40_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff0000000000,); + } +} +func warp_int40_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff0000000000,); + } +} +func warp_int40_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff0000000000,); + } +} +func warp_int40_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000,); + } +} +func warp_int40_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x8000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffffffffffffffff0000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int48_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int48_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int48_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int48_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int48_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} + +func warp_int48_to_int56{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff000000000000,); + } +} +func warp_int48_to_int64{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff000000000000,); + } +} +func warp_int48_to_int72{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff000000000000,); + } +} +func warp_int48_to_int80{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff000000000000,); + } +} +func warp_int48_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff000000000000,); + } +} +func warp_int48_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff000000000000,); + } +} +func warp_int48_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff000000000000,); + } +} +func warp_int48_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff000000000000,); + } +} +func warp_int48_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffffff000000000000,); + } +} +func warp_int48_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x800000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffffffffffffff000000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int56_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int56_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int56_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int56_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int56_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int56_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} + +func warp_int56_to_int64{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff00000000000000,); + } +} +func warp_int56_to_int72{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff00000000000000,); + } +} +func warp_int56_to_int80{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff00000000000000,); + } +} +func warp_int56_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff00000000000000,); + } +} +func warp_int56_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff00000000000000,); + } +} +func warp_int56_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff00000000000000,); + } +} +func warp_int56_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff00000000000000,); + } +} +func warp_int56_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffffff00000000000000,); + } +} +func warp_int56_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffffffffffff00000000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int64_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int64_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int64_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int64_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int64_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int64_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int64_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} + +func warp_int64_to_int72{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff0000000000000000,); + } +} +func warp_int64_to_int80{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff0000000000000000,); + } +} +func warp_int64_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff0000000000000000,); + } +} +func warp_int64_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff0000000000000000,); + } +} +func warp_int64_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff0000000000000000,); + } +} +func warp_int64_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff0000000000000000,); + } +} +func warp_int64_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffffff0000000000000000,); + } +} +func warp_int64_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x8000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffffffffff0000000000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int72_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int72_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int72_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int72_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int72_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int72_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int72_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int72_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} + +func warp_int72_to_int80{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff000000000000000000,); + } +} +func warp_int72_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff000000000000000000,); + } +} +func warp_int72_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff000000000000000000,); + } +} +func warp_int72_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff000000000000000000,); + } +} +func warp_int72_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff000000000000000000,); + } +} +func warp_int72_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff000000000000000000,); + } +} +func warp_int72_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffffff000000000000000000,); + } +} +func warp_int72_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x800000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffffffff000000000000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int80_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int80_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int80_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int80_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int80_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int80_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int80_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int80_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int80_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} + +func warp_int80_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff00000000000000000000,); + } +} +func warp_int80_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff00000000000000000000,); + } +} +func warp_int80_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff00000000000000000000,); + } +} +func warp_int80_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff00000000000000000000,); + } +} +func warp_int80_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff00000000000000000000,); + } +} +func warp_int80_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffffff00000000000000000000,); + } +} +func warp_int80_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffffff00000000000000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int88_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int88_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int88_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int88_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int88_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int88_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int88_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int88_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int88_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int88_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} + +func warp_int88_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff0000000000000000000000,); + } +} +func warp_int88_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff0000000000000000000000,); + } +} +func warp_int88_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff0000000000000000000000,); + } +} +func warp_int88_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff0000000000000000000000,); + } +} +func warp_int88_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffffff0000000000000000000000,); + } +} +func warp_int88_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x8000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffffff0000000000000000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int96_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int96_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int96_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int96_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int96_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int96_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int96_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int96_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int96_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int96_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int96_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} + +func warp_int96_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff000000000000000000000000,); + } +} +func warp_int96_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff000000000000000000000000,); + } +} +func warp_int96_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff000000000000000000000000,); + } +} +func warp_int96_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff000000000000000000000000,); + } +} +func warp_int96_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffffff000000000000000000000000,); + } +} +func warp_int96_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x800000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffffff000000000000000000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int104_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int104_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int104_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int104_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int104_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int104_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int104_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int104_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int104_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int104_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int104_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int104_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} + +func warp_int104_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff00000000000000000000000000,); + } +} +func warp_int104_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff00000000000000000000000000,); + } +} +func warp_int104_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff00000000000000000000000000,); + } +} +func warp_int104_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffffff00000000000000000000000000,); + } +} +func warp_int104_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffffff00000000000000000000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int112_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int112_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int112_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int112_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int112_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int112_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int112_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int112_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int112_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int112_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int112_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int112_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int112_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} + +func warp_int112_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff0000000000000000000000000000,); + } +} +func warp_int112_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff0000000000000000000000000000,); + } +} +func warp_int112_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffffff0000000000000000000000000000,); + } +} +func warp_int112_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xffff0000000000000000000000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int120_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int120_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int120_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int120_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int120_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int120_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int120_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int120_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int120_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int120_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int120_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int120_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int120_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int120_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int120_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff000000000000000000000000000000,); + } +} +func warp_int120_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff000000000000000000000000000000,); + } +} +func warp_int120_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffffff000000000000000000000000000000,); + } +} +func warp_int120_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0xff000000000000000000000000000000, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int128_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int128_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int128_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int128_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int128_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int128_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int128_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int128_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int128_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int128_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int128_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int128_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int128_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int128_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int128_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int128_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff00000000000000000000000000000000,); + } +} +func warp_int128_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffffff00000000000000000000000000000000,); + } +} +func warp_int128_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffffffffffffffffffffffff)); + return (res,); + } +} +func warp_int136_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int136_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int136_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int136_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int136_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int136_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int136_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int136_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int136_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int136_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int136_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int136_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int136_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int136_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int136_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int136_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int136_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffffff0000000000000000000000000000000000,); + } +} +func warp_int136_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffffffffffffffffffffff00)); + return (res,); + } +} +func warp_int144_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int144_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int144_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int144_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int144_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int144_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int144_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int144_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int144_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int144_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int144_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int144_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int144_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int144_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int144_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int144_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int144_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int144_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffffff000000000000000000000000000000000000,); + } +} +func warp_int144_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffffffffffffffffffff0000)); + return (res,); + } +} +func warp_int152_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int152_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int152_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int152_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int152_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int152_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int152_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int152_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int152_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int152_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int152_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int152_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int152_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int152_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int152_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int152_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int152_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int152_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int152_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffffff00000000000000000000000000000000000000,); + } +} +func warp_int152_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffffffffffffffffff000000)); + return (res,); + } +} +func warp_int160_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int160_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int160_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int160_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int160_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int160_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int160_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int160_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int160_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int160_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int160_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int160_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int160_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int160_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int160_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int160_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int160_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int160_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int160_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int160_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffffff0000000000000000000000000000000000000000,); + } +} +func warp_int160_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffffffffffffffff00000000)); + return (res,); + } +} +func warp_int168_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int168_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int168_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int168_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int168_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int168_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int168_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int168_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int168_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int168_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int168_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int168_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int168_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int168_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int168_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int168_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int168_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int168_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int168_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int168_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int168_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff000000000000000000000000000000000000000000,); + } +} +func warp_int168_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff000000000000000000000000000000000000000000,); + } +} +func warp_int168_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff000000000000000000000000000000000000000000,); + } +} +func warp_int168_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff000000000000000000000000000000000000000000,); + } +} +func warp_int168_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff000000000000000000000000000000000000000000,); + } +} +func warp_int168_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff000000000000000000000000000000000000000000,); + } +} +func warp_int168_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff000000000000000000000000000000000000000000,); + } +} +func warp_int168_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff000000000000000000000000000000000000000000,); + } +} +func warp_int168_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff000000000000000000000000000000000000000000,); + } +} +func warp_int168_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffffff000000000000000000000000000000000000000000,); + } +} +func warp_int168_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffffffffffffff0000000000)); + return (res,); + } +} +func warp_int176_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int176_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int176_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int176_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int176_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int176_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int176_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int176_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int176_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int176_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int176_to_int168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int176_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff00000000000000000000000000000000000000000000,); + } +} +func warp_int176_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff00000000000000000000000000000000000000000000,); + } +} +func warp_int176_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff00000000000000000000000000000000000000000000,); + } +} +func warp_int176_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff00000000000000000000000000000000000000000000,); + } +} +func warp_int176_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff00000000000000000000000000000000000000000000,); + } +} +func warp_int176_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff00000000000000000000000000000000000000000000,); + } +} +func warp_int176_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff00000000000000000000000000000000000000000000,); + } +} +func warp_int176_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff00000000000000000000000000000000000000000000,); + } +} +func warp_int176_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffffff00000000000000000000000000000000000000000000,); + } +} +func warp_int176_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffffffffffff000000000000)); + return (res,); + } +} +func warp_int184_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int184_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int184_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int184_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int184_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int184_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int184_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int184_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int184_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int184_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int184_to_int176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int184_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff0000000000000000000000000000000000000000000000,); + } +} +func warp_int184_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff0000000000000000000000000000000000000000000000,); + } +} +func warp_int184_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff0000000000000000000000000000000000000000000000,); + } +} +func warp_int184_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff0000000000000000000000000000000000000000000000,); + } +} +func warp_int184_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff0000000000000000000000000000000000000000000000,); + } +} +func warp_int184_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff0000000000000000000000000000000000000000000000,); + } +} +func warp_int184_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff0000000000000000000000000000000000000000000000,); + } +} +func warp_int184_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffffff0000000000000000000000000000000000000000000000,); + } +} +func warp_int184_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffffffffff00000000000000)); + return (res,); + } +} +func warp_int192_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int192_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int192_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int192_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int192_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int192_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int192_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int192_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int192_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int192_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int192_to_int184{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int192_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff000000000000000000000000000000000000000000000000,); + } +} +func warp_int192_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff000000000000000000000000000000000000000000000000,); + } +} +func warp_int192_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff000000000000000000000000000000000000000000000000,); + } +} +func warp_int192_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff000000000000000000000000000000000000000000000000,); + } +} +func warp_int192_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff000000000000000000000000000000000000000000000000,); + } +} +func warp_int192_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff000000000000000000000000000000000000000000000000,); + } +} +func warp_int192_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffffff000000000000000000000000000000000000000000000000,); + } +} +func warp_int192_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffffffff0000000000000000)); + return (res,); + } +} +func warp_int200_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int200_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int200_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int200_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int200_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int200_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int200_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int200_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int200_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int200_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int184{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int200_to_int192{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int200_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff00000000000000000000000000000000000000000000000000,); + } +} +func warp_int200_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff00000000000000000000000000000000000000000000000000,); + } +} +func warp_int200_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff00000000000000000000000000000000000000000000000000,); + } +} +func warp_int200_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff00000000000000000000000000000000000000000000000000,); + } +} +func warp_int200_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff00000000000000000000000000000000000000000000000000,); + } +} +func warp_int200_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffffff00000000000000000000000000000000000000000000000000,); + } +} +func warp_int200_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffffff000000000000000000)); + return (res,); + } +} +func warp_int208_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int208_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int208_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int208_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int208_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int208_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int208_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int208_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int208_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int208_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int184{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int192{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int208_to_int200{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int208_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff0000000000000000000000000000000000000000000000000000,); + } +} +func warp_int208_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff0000000000000000000000000000000000000000000000000000,); + } +} +func warp_int208_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff0000000000000000000000000000000000000000000000000000,); + } +} +func warp_int208_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff0000000000000000000000000000000000000000000000000000,); + } +} +func warp_int208_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffffff0000000000000000000000000000000000000000000000000000,); + } +} +func warp_int208_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffffff00000000000000000000)); + return (res,); + } +} +func warp_int216_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int216_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int216_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int216_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int216_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int216_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int216_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int216_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int216_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int216_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int184{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int192{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int200{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int216_to_int208{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int216_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff000000000000000000000000000000000000000000000000000000,); + } +} +func warp_int216_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff000000000000000000000000000000000000000000000000000000,); + } +} +func warp_int216_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff000000000000000000000000000000000000000000000000000000,); + } +} +func warp_int216_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffffff000000000000000000000000000000000000000000000000000000,); + } +} +func warp_int216_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffffff0000000000000000000000)); + return (res,); + } +} +func warp_int224_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int224_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int224_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int224_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int224_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int224_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int224_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int224_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int224_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int224_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int184{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int192{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int200{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int208{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int224_to_int216{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int224_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff00000000000000000000000000000000000000000000000000000000,); + } +} +func warp_int224_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff00000000000000000000000000000000000000000000000000000000,); + } +} +func warp_int224_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffffff00000000000000000000000000000000000000000000000000000000,); + } +} +func warp_int224_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffffff000000000000000000000000)); + return (res,); + } +} +func warp_int232_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int232_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int232_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int232_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int232_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int232_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int232_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int232_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int232_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int232_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int184{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int192{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int200{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int208{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int216{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int232_to_int224{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int232_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff0000000000000000000000000000000000000000000000000000000000,); + } +} +func warp_int232_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xffff0000000000000000000000000000000000000000000000000000000000,); + } +} +func warp_int232_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x8000000000000000000000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffffff00000000000000000000000000)); + return (res,); + } +} +func warp_int240_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int240_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int240_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int240_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int240_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int240_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int240_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int240_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int240_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int240_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int184{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int192{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int200{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int208{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int216{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int224{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int240_to_int232{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int240_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000000000000000); + if (msb == 0){ + return (op,); + }else{ + return (op + 0xff000000000000000000000000000000000000000000000000000000000000,); + } +} +func warp_int240_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x800000000000000000000000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xffff0000000000000000000000000000)); + return (res,); + } +} +func warp_int248_to_int8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xff); + return (res,); +} +func warp_int248_to_int16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffff); + return (res,); +} +func warp_int248_to_int24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffff); + return (res,); +} +func warp_int248_to_int32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffff); + return (res,); +} +func warp_int248_to_int40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffff); + return (res,); +} +func warp_int248_to_int48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffff); + return (res,); +} +func warp_int248_to_int56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffff); + return (res,); +} +func warp_int248_to_int64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffff); + return (res,); +} +func warp_int248_to_int72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffff); + return (res,); +} +func warp_int248_to_int80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int184{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int192{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int200{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int208{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int216{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int224{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int232{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int248_to_int240{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let (res) = bitwise_and(op, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} + +func warp_int248_to_int256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(op : felt) -> (res : Uint256){ + let (msb) = bitwise_and(op, 0x80000000000000000000000000000000000000000000000000000000000000); + let (high, low) = split_felt(op); + let naiveExtension = Uint256(low, high); + if (msb == 0){ + return (naiveExtension,); + }else{ + let (res, _) = uint256_add(naiveExtension, Uint256(0x0, 0xff000000000000000000000000000000)); + return (res,); + } +} +func warp_int256_to_int8{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xff); + return (res,); +} +func warp_int256_to_int16{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffff); + return (res,); +} +func warp_int256_to_int24{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffff); + return (res,); +} +func warp_int256_to_int32{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffff); + return (res,); +} +func warp_int256_to_int40{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffff); + return (res,); +} +func warp_int256_to_int48{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffff); + return (res,); +} +func warp_int256_to_int56{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffffff); + return (res,); +} +func warp_int256_to_int64{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffffffff); + return (res,); +} +func warp_int256_to_int72{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffffffffff); + return (res,); +} +func warp_int256_to_int80{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffffffffffff); + return (res,); +} +func warp_int256_to_int88{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffffffffffffff); + return (res,); +} +func warp_int256_to_int96{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_int256_to_int104{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_int256_to_int112{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_int256_to_int120{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int256_to_int128{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (res) = bitwise_and(op.low, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_int256_to_int136{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int144{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int152{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int160{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int168{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int176{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int184{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int192{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int200{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int208{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffffffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int216{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffffffffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int224{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffffffffffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int232{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffffffffffffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int240{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffffffffffffffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} +func warp_int256_to_int248{bitwise_ptr: BitwiseBuiltin*}(op : Uint256) -> (res : felt){ + let (high) = bitwise_and(op.high,0xffffffffffffffffffffffffffffff); + return (op.low + 0x100000000000000000000000000000000 * high,); +} + +func warp_uint256{range_check_ptr}(op : felt) -> (res : Uint256){ + let split = split_felt(op); + return (Uint256(low=split.low, high=split.high),); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/le.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/le.cairo new file mode 100644 index 000000000..ab09314f7 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/le.cairo @@ -0,0 +1,12 @@ +from starkware.cairo.common.math_cmp import is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_le + +func warp_le{range_check_ptr}(lhs: felt, rhs: felt) -> (res: felt) { + let res = is_le_felt(lhs, rhs); + return (res,); +} + +func warp_le256{range_check_ptr}(lhs: Uint256, rhs: Uint256) -> (result: felt) { + let (res) = uint256_le(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/le_signed.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/le_signed.cairo new file mode 100644 index 000000000..ca582e037 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/le_signed.cairo @@ -0,0 +1,909 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.math_cmp import is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_signed_le + +func warp_le_signed8{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed16{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x8000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x8000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed24{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x800000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x800000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed32{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed40{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x8000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x8000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed48{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x800000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x800000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed56{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed64{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x8000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x8000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed72{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x800000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x800000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed80{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed88{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed96{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed104{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed112{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed120{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed128{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed136{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed144{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed152{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed160{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed168{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed176{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed184{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed192{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed200{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed208{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed216{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed224{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed232{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed240{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed248{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (lhs_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000000000); + let (rhs_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + // lhs >= 0 + if (rhs_msb == 0){ + // rhs >= 0 + let result = is_le_felt(lhs, rhs); + return (result,); + }else{ + // rhs < 0 + return (0,); + } + }else{ + // lhs < 0 + if (rhs_msb == 0){ + // rhs >= 0 + return (1,); + }else{ + // rhs < 0 + // (signed) lhs <= rhs <=> (unsigned) lhs >= rhs + let result = is_le_felt(lhs, rhs); + return (result,); + } + } +} +func warp_le_signed256{range_check_ptr}(lhs : Uint256, rhs : Uint256) -> (res : felt){ + let (res) = uint256_signed_le(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/lt.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/lt.cairo new file mode 100644 index 000000000..ce19c629f --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/lt.cairo @@ -0,0 +1,15 @@ +from starkware.cairo.common.math_cmp import is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_lt + +func warp_lt{range_check_ptr}(lhs: felt, rhs: felt) -> (res: felt) { + if (lhs == rhs) { + return (0,); + } + let res = is_le_felt(lhs, rhs); + return (res,); +} + +func warp_lt256{range_check_ptr}(lhs: Uint256, rhs: Uint256) -> (res: felt) { + let (res) = uint256_lt(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/lt_signed.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/lt_signed.cairo new file mode 100644 index 000000000..9738d4c46 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/lt_signed.cairo @@ -0,0 +1,258 @@ +//AUTO-GENERATED +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_signed_lt +from warplib.maths.utils import felt_to_uint256 +from warplib.maths.le_signed import warp_le_signed8, warp_le_signed16, warp_le_signed24, warp_le_signed32, warp_le_signed40, warp_le_signed48, warp_le_signed56, warp_le_signed64, warp_le_signed72, warp_le_signed80, warp_le_signed88, warp_le_signed96, warp_le_signed104, warp_le_signed112, warp_le_signed120, warp_le_signed128, warp_le_signed136, warp_le_signed144, warp_le_signed152, warp_le_signed160, warp_le_signed168, warp_le_signed176, warp_le_signed184, warp_le_signed192, warp_le_signed200, warp_le_signed208, warp_le_signed216, warp_le_signed224, warp_le_signed232, warp_le_signed240, warp_le_signed248 + +func warp_lt_signed8{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed8(lhs, rhs); + return (res,); +} +func warp_lt_signed16{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed16(lhs, rhs); + return (res,); +} +func warp_lt_signed24{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed24(lhs, rhs); + return (res,); +} +func warp_lt_signed32{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed32(lhs, rhs); + return (res,); +} +func warp_lt_signed40{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed40(lhs, rhs); + return (res,); +} +func warp_lt_signed48{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed48(lhs, rhs); + return (res,); +} +func warp_lt_signed56{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed56(lhs, rhs); + return (res,); +} +func warp_lt_signed64{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed64(lhs, rhs); + return (res,); +} +func warp_lt_signed72{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed72(lhs, rhs); + return (res,); +} +func warp_lt_signed80{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed80(lhs, rhs); + return (res,); +} +func warp_lt_signed88{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed88(lhs, rhs); + return (res,); +} +func warp_lt_signed96{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed96(lhs, rhs); + return (res,); +} +func warp_lt_signed104{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed104(lhs, rhs); + return (res,); +} +func warp_lt_signed112{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed112(lhs, rhs); + return (res,); +} +func warp_lt_signed120{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed120(lhs, rhs); + return (res,); +} +func warp_lt_signed128{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed128(lhs, rhs); + return (res,); +} +func warp_lt_signed136{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed136(lhs, rhs); + return (res,); +} +func warp_lt_signed144{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed144(lhs, rhs); + return (res,); +} +func warp_lt_signed152{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed152(lhs, rhs); + return (res,); +} +func warp_lt_signed160{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed160(lhs, rhs); + return (res,); +} +func warp_lt_signed168{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed168(lhs, rhs); + return (res,); +} +func warp_lt_signed176{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed176(lhs, rhs); + return (res,); +} +func warp_lt_signed184{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed184(lhs, rhs); + return (res,); +} +func warp_lt_signed192{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed192(lhs, rhs); + return (res,); +} +func warp_lt_signed200{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed200(lhs, rhs); + return (res,); +} +func warp_lt_signed208{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed208(lhs, rhs); + return (res,); +} +func warp_lt_signed216{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed216(lhs, rhs); + return (res,); +} +func warp_lt_signed224{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed224(lhs, rhs); + return (res,); +} +func warp_lt_signed232{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed232(lhs, rhs); + return (res,); +} +func warp_lt_signed240{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed240(lhs, rhs); + return (res,); +} +func warp_lt_signed248{bitwise_ptr : BitwiseBuiltin*, range_check_ptr}( + lhs : felt, rhs : felt) -> (res : felt){ + if (lhs == rhs){ + return (0,); + } + let (res) = warp_le_signed248(lhs, rhs); + return (res,); +} +func warp_lt_signed256{range_check_ptr}(lhs : Uint256, rhs : Uint256) -> (res : felt){ + let (res) = uint256_signed_lt(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/mod.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/mod.cairo new file mode 100644 index 000000000..4c87b8b62 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/mod.cairo @@ -0,0 +1,28 @@ +from starkware.cairo.common.uint256 import Uint256, uint256_unsigned_div_rem +from warplib.maths.utils import felt_to_uint256 + +const SHIFT = 2 ** 128; + +func warp_mod{range_check_ptr}(lhs: felt, rhs: felt) -> (res: felt) { + if (rhs == 0) { + with_attr error_message("Modulo by zero error") { + assert 1 = 0; + } + } + let (lhs_256) = felt_to_uint256(lhs); + let (rhs_256) = felt_to_uint256(rhs); + let (_, res256) = uint256_unsigned_div_rem(lhs_256, rhs_256); + return (res256.low + SHIFT * res256.high,); +} + +func warp_mod256{range_check_ptr}(lhs: Uint256, rhs: Uint256) -> (res: Uint256) { + if (rhs.high == 0) { + if (rhs.low == 0) { + with_attr error_message("Modulo by zero error") { + assert 1 = 0; + } + } + } + let (_, res: Uint256) = uint256_unsigned_div_rem(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/mod_signed.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/mod_signed.cairo new file mode 100644 index 000000000..573a04383 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/mod_signed.cairo @@ -0,0 +1,419 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_signed_div_rem +from warplib.maths.utils import felt_to_uint256 +from warplib.maths.int_conversions import warp_int8_to_int256, warp_int16_to_int256, warp_int24_to_int256, warp_int32_to_int256, warp_int40_to_int256, warp_int48_to_int256, warp_int56_to_int256, warp_int64_to_int256, warp_int72_to_int256, warp_int80_to_int256, warp_int88_to_int256, warp_int96_to_int256, warp_int104_to_int256, warp_int112_to_int256, warp_int120_to_int256, warp_int128_to_int256, warp_int136_to_int256, warp_int144_to_int256, warp_int152_to_int256, warp_int160_to_int256, warp_int168_to_int256, warp_int176_to_int256, warp_int184_to_int256, warp_int192_to_int256, warp_int200_to_int256, warp_int208_to_int256, warp_int216_to_int256, warp_int224_to_int256, warp_int232_to_int256, warp_int240_to_int256, warp_int248_to_int256, warp_int256_to_int8, warp_int256_to_int16, warp_int256_to_int24, warp_int256_to_int32, warp_int256_to_int40, warp_int256_to_int48, warp_int256_to_int56, warp_int256_to_int64, warp_int256_to_int72, warp_int256_to_int80, warp_int256_to_int88, warp_int256_to_int96, warp_int256_to_int104, warp_int256_to_int112, warp_int256_to_int120, warp_int256_to_int128, warp_int256_to_int136, warp_int256_to_int144, warp_int256_to_int152, warp_int256_to_int160, warp_int256_to_int168, warp_int256_to_int176, warp_int256_to_int184, warp_int256_to_int192, warp_int256_to_int200, warp_int256_to_int208, warp_int256_to_int216, warp_int256_to_int224, warp_int256_to_int232, warp_int256_to_int240, warp_int256_to_int248 + +func warp_mod_signed8{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int8_to_int256(lhs); + let (rhs_256) = warp_int8_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int8(res256); + return (truncated,); +} +func warp_mod_signed16{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int16_to_int256(lhs); + let (rhs_256) = warp_int16_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int16(res256); + return (truncated,); +} +func warp_mod_signed24{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int24_to_int256(lhs); + let (rhs_256) = warp_int24_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int24(res256); + return (truncated,); +} +func warp_mod_signed32{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int32_to_int256(lhs); + let (rhs_256) = warp_int32_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int32(res256); + return (truncated,); +} +func warp_mod_signed40{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int40_to_int256(lhs); + let (rhs_256) = warp_int40_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int40(res256); + return (truncated,); +} +func warp_mod_signed48{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int48_to_int256(lhs); + let (rhs_256) = warp_int48_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int48(res256); + return (truncated,); +} +func warp_mod_signed56{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int56_to_int256(lhs); + let (rhs_256) = warp_int56_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int56(res256); + return (truncated,); +} +func warp_mod_signed64{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int64_to_int256(lhs); + let (rhs_256) = warp_int64_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int64(res256); + return (truncated,); +} +func warp_mod_signed72{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int72_to_int256(lhs); + let (rhs_256) = warp_int72_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int72(res256); + return (truncated,); +} +func warp_mod_signed80{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int80_to_int256(lhs); + let (rhs_256) = warp_int80_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int80(res256); + return (truncated,); +} +func warp_mod_signed88{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int88_to_int256(lhs); + let (rhs_256) = warp_int88_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int88(res256); + return (truncated,); +} +func warp_mod_signed96{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int96_to_int256(lhs); + let (rhs_256) = warp_int96_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int96(res256); + return (truncated,); +} +func warp_mod_signed104{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int104_to_int256(lhs); + let (rhs_256) = warp_int104_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int104(res256); + return (truncated,); +} +func warp_mod_signed112{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int112_to_int256(lhs); + let (rhs_256) = warp_int112_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int112(res256); + return (truncated,); +} +func warp_mod_signed120{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int120_to_int256(lhs); + let (rhs_256) = warp_int120_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int120(res256); + return (truncated,); +} +func warp_mod_signed128{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int128_to_int256(lhs); + let (rhs_256) = warp_int128_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int128(res256); + return (truncated,); +} +func warp_mod_signed136{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int136_to_int256(lhs); + let (rhs_256) = warp_int136_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int136(res256); + return (truncated,); +} +func warp_mod_signed144{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int144_to_int256(lhs); + let (rhs_256) = warp_int144_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int144(res256); + return (truncated,); +} +func warp_mod_signed152{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int152_to_int256(lhs); + let (rhs_256) = warp_int152_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int152(res256); + return (truncated,); +} +func warp_mod_signed160{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int160_to_int256(lhs); + let (rhs_256) = warp_int160_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int160(res256); + return (truncated,); +} +func warp_mod_signed168{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int168_to_int256(lhs); + let (rhs_256) = warp_int168_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int168(res256); + return (truncated,); +} +func warp_mod_signed176{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int176_to_int256(lhs); + let (rhs_256) = warp_int176_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int176(res256); + return (truncated,); +} +func warp_mod_signed184{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int184_to_int256(lhs); + let (rhs_256) = warp_int184_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int184(res256); + return (truncated,); +} +func warp_mod_signed192{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int192_to_int256(lhs); + let (rhs_256) = warp_int192_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int192(res256); + return (truncated,); +} +func warp_mod_signed200{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int200_to_int256(lhs); + let (rhs_256) = warp_int200_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int200(res256); + return (truncated,); +} +func warp_mod_signed208{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int208_to_int256(lhs); + let (rhs_256) = warp_int208_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int208(res256); + return (truncated,); +} +func warp_mod_signed216{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int216_to_int256(lhs); + let (rhs_256) = warp_int216_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int216(res256); + return (truncated,); +} +func warp_mod_signed224{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int224_to_int256(lhs); + let (rhs_256) = warp_int224_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int224(res256); + return (truncated,); +} +func warp_mod_signed232{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int232_to_int256(lhs); + let (rhs_256) = warp_int232_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int232(res256); + return (truncated,); +} +func warp_mod_signed240{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int240_to_int256(lhs); + let (rhs_256) = warp_int240_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int240(res256); + return (truncated,); +} +func warp_mod_signed248{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + if (rhs == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (local lhs_256) = warp_int248_to_int256(lhs); + let (rhs_256) = warp_int248_to_int256(rhs); + let (_, res256) = uint256_signed_div_rem(lhs_256, rhs_256); + let (truncated) = warp_int256_to_int248(res256); + return (truncated,); +} +func warp_mod_signed256{range_check_ptr}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + if (rhs.high == 0 and rhs.low == 0){ + with_attr error_message("Modulo by zero error"){ + assert 1 = 0; + } + } + let (_, res : Uint256) = uint256_signed_div_rem(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/mul.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/mul.cairo new file mode 100644 index 000000000..ec21748c9 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/mul.cairo @@ -0,0 +1,246 @@ +//AUTO-GENERATED +from starkware.cairo.common.uint256 import Uint256, uint256_mul +from starkware.cairo.common.math_cmp import is_le_felt +from warplib.maths.ge import warp_ge256 +from warplib.maths.utils import felt_to_uint256 + +func warp_mul8{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xff); + assert inRange = 1; + return (res,); +} +func warp_mul16{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffff); + assert inRange = 1; + return (res,); +} +func warp_mul24{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffff); + assert inRange = 1; + return (res,); +} +func warp_mul32{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul40{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul48{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul56{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul64{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul72{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul80{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffffffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul88{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffffffffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul96{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffffffffffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul104{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffffffffffffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul112{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffffffffffffffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul120{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + let res = lhs * rhs; + let inRange : felt = is_le_felt(res, 0xffffffffffffffffffffffffffffff); + assert inRange = 1; + return (res,); +} +func warp_mul128{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x1)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul136{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x100)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul144{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x10000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul152{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x1000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul160{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x100000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul168{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x10000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul176{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x1000000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul184{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x100000000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul192{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x10000000000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul200{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x1000000000000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul208{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x100000000000000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul216{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x10000000000000000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul224{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x1000000000000000000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul232{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x100000000000000000000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul240{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x10000000000000000000000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul248{range_check_ptr}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256) = warp_mul256(l256, r256); + let (outOfRange : felt) = warp_ge256(res, Uint256(0x0, 0x1000000000000000000000000000000)); + assert outOfRange = 0; + return (res.low + 0x100000000000000000000000000000000 * res.high,); +} +func warp_mul256{range_check_ptr}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + let (result : Uint256, overflow : Uint256) = uint256_mul(lhs, rhs); + assert overflow.low = 0; + assert overflow.high = 0; + return (result,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/mul_signed.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/mul_signed.cairo new file mode 100644 index 000000000..7869bbac3 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/mul_signed.cairo @@ -0,0 +1,1214 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.math_cmp import is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_mul, uint256_cond_neg, uint256_signed_nn, uint256_neg, uint256_le +from warplib.maths.utils import felt_to_uint256 +from warplib.maths.le import warp_le +from warplib.maths.mul import warp_mul8, warp_mul16, warp_mul24, warp_mul32, warp_mul40, warp_mul48, warp_mul56, warp_mul64, warp_mul72, warp_mul80, warp_mul88, warp_mul96, warp_mul104, warp_mul112, warp_mul120, warp_mul128, warp_mul136, warp_mul144, warp_mul152, warp_mul160, warp_mul168, warp_mul176, warp_mul184, warp_mul192, warp_mul200, warp_mul208, warp_mul216, warp_mul224, warp_mul232, warp_mul240, warp_mul248 +from warplib.maths.negate import warp_negate8, warp_negate16, warp_negate24, warp_negate32, warp_negate40, warp_negate48, warp_negate56, warp_negate64, warp_negate72, warp_negate80, warp_negate88, warp_negate96, warp_negate104, warp_negate112, warp_negate120, warp_negate128, warp_negate136, warp_negate144, warp_negate152, warp_negate160, warp_negate168, warp_negate176, warp_negate184, warp_negate192, warp_negate200, warp_negate208, warp_negate216, warp_negate224, warp_negate232, warp_negate240, warp_negate248 + +func warp_mul_signed8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80); + if (right_msb == 0){ + let (res) = warp_mul8(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate8(rhs); + let (res_abs) = warp_mul8(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80); + assert in_range = 1; + let (res) = warp_negate8(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80); + if (right_msb == 0){ + let (lhs_abs) = warp_negate8(lhs); + let (res_abs) = warp_mul8(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80); + assert in_range = 1; + let (res) = warp_negate8(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate8(lhs); + let (rhs_abs) = warp_negate8(rhs); + let (res) = warp_mul8(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x8000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x8000); + if (right_msb == 0){ + let (res) = warp_mul16(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x8000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate16(rhs); + let (res_abs) = warp_mul16(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x8000); + assert in_range = 1; + let (res) = warp_negate16(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x8000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate16(lhs); + let (res_abs) = warp_mul16(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x8000); + assert in_range = 1; + let (res) = warp_negate16(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate16(lhs); + let (rhs_abs) = warp_negate16(rhs); + let (res) = warp_mul16(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x8000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x800000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x800000); + if (right_msb == 0){ + let (res) = warp_mul24(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x800000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate24(rhs); + let (res_abs) = warp_mul24(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x800000); + assert in_range = 1; + let (res) = warp_negate24(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x800000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate24(lhs); + let (res_abs) = warp_mul24(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x800000); + assert in_range = 1; + let (res) = warp_negate24(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate24(lhs); + let (rhs_abs) = warp_negate24(rhs); + let (res) = warp_mul24(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x800000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80000000); + if (right_msb == 0){ + let (res) = warp_mul32(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate32(rhs); + let (res_abs) = warp_mul32(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80000000); + assert in_range = 1; + let (res) = warp_negate32(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate32(lhs); + let (res_abs) = warp_mul32(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80000000); + assert in_range = 1; + let (res) = warp_negate32(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate32(lhs); + let (rhs_abs) = warp_negate32(rhs); + let (res) = warp_mul32(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x8000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x8000000000); + if (right_msb == 0){ + let (res) = warp_mul40(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x8000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate40(rhs); + let (res_abs) = warp_mul40(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x8000000000); + assert in_range = 1; + let (res) = warp_negate40(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x8000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate40(lhs); + let (res_abs) = warp_mul40(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x8000000000); + assert in_range = 1; + let (res) = warp_negate40(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate40(lhs); + let (rhs_abs) = warp_negate40(rhs); + let (res) = warp_mul40(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x8000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x800000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x800000000000); + if (right_msb == 0){ + let (res) = warp_mul48(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x800000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate48(rhs); + let (res_abs) = warp_mul48(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x800000000000); + assert in_range = 1; + let (res) = warp_negate48(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x800000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate48(lhs); + let (res_abs) = warp_mul48(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x800000000000); + assert in_range = 1; + let (res) = warp_negate48(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate48(lhs); + let (rhs_abs) = warp_negate48(rhs); + let (res) = warp_mul48(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x800000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80000000000000); + if (right_msb == 0){ + let (res) = warp_mul56(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate56(rhs); + let (res_abs) = warp_mul56(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80000000000000); + assert in_range = 1; + let (res) = warp_negate56(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate56(lhs); + let (res_abs) = warp_mul56(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80000000000000); + assert in_range = 1; + let (res) = warp_negate56(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate56(lhs); + let (rhs_abs) = warp_negate56(rhs); + let (res) = warp_mul56(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x8000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000); + if (right_msb == 0){ + let (res) = warp_mul64(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x8000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate64(rhs); + let (res_abs) = warp_mul64(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x8000000000000000); + assert in_range = 1; + let (res) = warp_negate64(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate64(lhs); + let (res_abs) = warp_mul64(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x8000000000000000); + assert in_range = 1; + let (res) = warp_negate64(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate64(lhs); + let (rhs_abs) = warp_negate64(rhs); + let (res) = warp_mul64(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x8000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x800000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000); + if (right_msb == 0){ + let (res) = warp_mul72(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x800000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate72(rhs); + let (res_abs) = warp_mul72(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x800000000000000000); + assert in_range = 1; + let (res) = warp_negate72(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate72(lhs); + let (res_abs) = warp_mul72(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x800000000000000000); + assert in_range = 1; + let (res) = warp_negate72(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate72(lhs); + let (rhs_abs) = warp_negate72(rhs); + let (res) = warp_mul72(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x800000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul80(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate80(rhs); + let (res_abs) = warp_mul80(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000); + assert in_range = 1; + let (res) = warp_negate80(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate80(lhs); + let (res_abs) = warp_mul80(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000); + assert in_range = 1; + let (res) = warp_negate80(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate80(lhs); + let (rhs_abs) = warp_negate80(rhs); + let (res) = warp_mul80(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x8000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul88(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate88(rhs); + let (res_abs) = warp_mul88(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000); + assert in_range = 1; + let (res) = warp_negate88(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate88(lhs); + let (res_abs) = warp_mul88(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000); + assert in_range = 1; + let (res) = warp_negate88(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate88(lhs); + let (rhs_abs) = warp_negate88(rhs); + let (res) = warp_mul88(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x800000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul96(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate96(rhs); + let (res_abs) = warp_mul96(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000); + assert in_range = 1; + let (res) = warp_negate96(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate96(lhs); + let (res_abs) = warp_mul96(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000); + assert in_range = 1; + let (res) = warp_negate96(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate96(lhs); + let (rhs_abs) = warp_negate96(rhs); + let (res) = warp_mul96(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul104(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate104(rhs); + let (res_abs) = warp_mul104(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate104(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate104(lhs); + let (res_abs) = warp_mul104(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate104(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate104(lhs); + let (rhs_abs) = warp_negate104(rhs); + let (res) = warp_mul104(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul112(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate112(rhs); + let (res_abs) = warp_mul112(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate112(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate112(lhs); + let (res_abs) = warp_mul112(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate112(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate112(lhs); + let (rhs_abs) = warp_negate112(rhs); + let (res) = warp_mul112(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul120(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate120(rhs); + let (res_abs) = warp_mul120(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate120(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate120(lhs); + let (res_abs) = warp_mul120(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate120(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate120(lhs); + let (rhs_abs) = warp_negate120(rhs); + let (res) = warp_mul120(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul128(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate128(rhs); + let (res_abs) = warp_mul128(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate128(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate128(lhs); + let (res_abs) = warp_mul128(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate128(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate128(lhs); + let (rhs_abs) = warp_negate128(rhs); + let (res) = warp_mul128(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul136(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate136(rhs); + let (res_abs) = warp_mul136(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate136(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate136(lhs); + let (res_abs) = warp_mul136(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate136(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate136(lhs); + let (rhs_abs) = warp_negate136(rhs); + let (res) = warp_mul136(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul144(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate144(rhs); + let (res_abs) = warp_mul144(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate144(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate144(lhs); + let (res_abs) = warp_mul144(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate144(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate144(lhs); + let (rhs_abs) = warp_negate144(rhs); + let (res) = warp_mul144(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul152(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate152(rhs); + let (res_abs) = warp_mul152(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate152(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate152(lhs); + let (res_abs) = warp_mul152(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate152(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate152(lhs); + let (rhs_abs) = warp_negate152(rhs); + let (res) = warp_mul152(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul160(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate160(rhs); + let (res_abs) = warp_mul160(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate160(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate160(lhs); + let (res_abs) = warp_mul160(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate160(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate160(lhs); + let (rhs_abs) = warp_negate160(rhs); + let (res) = warp_mul160(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul168(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate168(rhs); + let (res_abs) = warp_mul168(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate168(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate168(lhs); + let (res_abs) = warp_mul168(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate168(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate168(lhs); + let (rhs_abs) = warp_negate168(rhs); + let (res) = warp_mul168(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul176(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate176(rhs); + let (res_abs) = warp_mul176(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate176(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate176(lhs); + let (res_abs) = warp_mul176(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate176(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate176(lhs); + let (rhs_abs) = warp_negate176(rhs); + let (res) = warp_mul176(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul184(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate184(rhs); + let (res_abs) = warp_mul184(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate184(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate184(lhs); + let (res_abs) = warp_mul184(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate184(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate184(lhs); + let (rhs_abs) = warp_negate184(rhs); + let (res) = warp_mul184(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul192(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate192(rhs); + let (res_abs) = warp_mul192(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate192(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate192(lhs); + let (res_abs) = warp_mul192(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate192(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate192(lhs); + let (rhs_abs) = warp_negate192(rhs); + let (res) = warp_mul192(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul200(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate200(rhs); + let (res_abs) = warp_mul200(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate200(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate200(lhs); + let (res_abs) = warp_mul200(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate200(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate200(lhs); + let (rhs_abs) = warp_negate200(rhs); + let (res) = warp_mul200(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul208(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate208(rhs); + let (res_abs) = warp_mul208(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate208(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate208(lhs); + let (res_abs) = warp_mul208(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate208(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate208(lhs); + let (rhs_abs) = warp_negate208(rhs); + let (res) = warp_mul208(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul216(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate216(rhs); + let (res_abs) = warp_mul216(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate216(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate216(lhs); + let (res_abs) = warp_mul216(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate216(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate216(lhs); + let (rhs_abs) = warp_negate216(rhs); + let (res) = warp_mul216(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul224(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate224(rhs); + let (res_abs) = warp_mul224(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate224(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate224(lhs); + let (res_abs) = warp_mul224(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate224(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate224(lhs); + let (rhs_abs) = warp_negate224(rhs); + let (res) = warp_mul224(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul232(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate232(rhs); + let (res_abs) = warp_mul232(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate232(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate232(lhs); + let (res_abs) = warp_mul232(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x8000000000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate232(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate232(lhs); + let (rhs_abs) = warp_negate232(rhs); + let (res) = warp_mul232(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x8000000000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul240(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate240(rhs); + let (res_abs) = warp_mul240(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate240(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate240(lhs); + let (res_abs) = warp_mul240(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x800000000000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate240(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate240(lhs); + let (rhs_abs) = warp_negate240(rhs); + let (res) = warp_mul240(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x800000000000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000000000); + if (left_msb == 0){ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (res) = warp_mul248(lhs, rhs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + }else{ + let (rhs_abs) = warp_negate248(rhs); + let (res_abs) = warp_mul248(lhs, rhs_abs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate248(res_abs); + return (res,); + } + }else{ + let (right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000000000); + if (right_msb == 0){ + let (lhs_abs) = warp_negate248(lhs); + let (res_abs) = warp_mul248(lhs_abs, rhs); + let (in_range) = warp_le(res_abs, 0x80000000000000000000000000000000000000000000000000000000000000); + assert in_range = 1; + let (res) = warp_negate248(res_abs); + return (res,); + }else{ + let (lhs_abs) = warp_negate248(lhs); + let (rhs_abs) = warp_negate248(rhs); + let (res) = warp_mul248(lhs_abs, rhs_abs); + let (res_msb) = bitwise_and(res, 0x80000000000000000000000000000000000000000000000000000000000000); + assert res_msb = 0; + return (res,); + } + } +} +func warp_mul_signed256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : Uint256, rhs : Uint256) -> (result : Uint256){ + alloc_locals; + // 1 => lhs >= 0, 0 => lhs < 0 + let (lhs_nn) = uint256_signed_nn(lhs); + // 1 => rhs >= 0, 0 => rhs < 0 + let (local rhs_nn) = uint256_signed_nn(rhs); + // negates if arg is 1, which is if lhs_nn is 0, which is if lhs < 0 + let (lhs_abs) = uint256_cond_neg(lhs, 1 - lhs_nn); + // negates if arg is 1 + let (rhs_abs) = uint256_cond_neg(rhs, 1 - rhs_nn); + let (res_abs, overflow) = uint256_mul(lhs_abs, rhs_abs); + assert overflow.low = 0; + assert overflow.high = 0; + let res_should_be_neg = lhs_nn + rhs_nn; + if (res_should_be_neg == 1){ + let (in_range) = uint256_le(res_abs, Uint256(0,0x80000000000000000000000000000000)); + assert in_range = 1; + let (negated) = uint256_neg(res_abs); + return (negated,); + }else{ + let (msb) = bitwise_and(res_abs.high, 0x80000000000000000000000000000000); + assert msb = 0; + return (res_abs,); + } +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/mul_signed_unsafe.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/mul_signed_unsafe.cairo new file mode 100644 index 000000000..00733b654 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/mul_signed_unsafe.cairo @@ -0,0 +1,454 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.math_cmp import is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_mul, uint256_cond_neg, uint256_signed_nn +from warplib.maths.mul_unsafe import warp_mul_unsafe8, warp_mul_unsafe16, warp_mul_unsafe24, warp_mul_unsafe32, warp_mul_unsafe40, warp_mul_unsafe48, warp_mul_unsafe56, warp_mul_unsafe64, warp_mul_unsafe72, warp_mul_unsafe80, warp_mul_unsafe88, warp_mul_unsafe96, warp_mul_unsafe104, warp_mul_unsafe112, warp_mul_unsafe120, warp_mul_unsafe128, warp_mul_unsafe136, warp_mul_unsafe144, warp_mul_unsafe152, warp_mul_unsafe160, warp_mul_unsafe168, warp_mul_unsafe176, warp_mul_unsafe184, warp_mul_unsafe192, warp_mul_unsafe200, warp_mul_unsafe208, warp_mul_unsafe216, warp_mul_unsafe224, warp_mul_unsafe232, warp_mul_unsafe240, warp_mul_unsafe248 +from warplib.maths.negate import warp_negate8, warp_negate16, warp_negate24, warp_negate32, warp_negate40, warp_negate48, warp_negate56, warp_negate64, warp_negate72, warp_negate80, warp_negate88, warp_negate96, warp_negate104, warp_negate112, warp_negate120, warp_negate128, warp_negate136, warp_negate144, warp_negate152, warp_negate160, warp_negate168, warp_negate176, warp_negate184, warp_negate192, warp_negate200, warp_negate208, warp_negate216, warp_negate224, warp_negate232, warp_negate240, warp_negate248 +from warplib.maths.utils import felt_to_uint256 + +func warp_mul_signed_unsafe8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80); + let (local right_msb) = bitwise_and(rhs, 0x80); + let (res) = warp_mul_unsafe8(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100 - left_msb - right_msb); + if (not_neg == 0x80){ + let (res) = warp_negate8(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x8000); + let (local right_msb) = bitwise_and(rhs, 0x8000); + let (res) = warp_mul_unsafe16(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x10000 - left_msb - right_msb); + if (not_neg == 0x8000){ + let (res) = warp_negate16(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x800000); + let (local right_msb) = bitwise_and(rhs, 0x800000); + let (res) = warp_mul_unsafe24(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x1000000 - left_msb - right_msb); + if (not_neg == 0x800000){ + let (res) = warp_negate24(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80000000); + let (local right_msb) = bitwise_and(rhs, 0x80000000); + let (res) = warp_mul_unsafe32(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100000000 - left_msb - right_msb); + if (not_neg == 0x80000000){ + let (res) = warp_negate32(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x8000000000); + let (local right_msb) = bitwise_and(rhs, 0x8000000000); + let (res) = warp_mul_unsafe40(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x10000000000 - left_msb - right_msb); + if (not_neg == 0x8000000000){ + let (res) = warp_negate40(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x800000000000); + let (local right_msb) = bitwise_and(rhs, 0x800000000000); + let (res) = warp_mul_unsafe48(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x1000000000000 - left_msb - right_msb); + if (not_neg == 0x800000000000){ + let (res) = warp_negate48(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80000000000000); + let (local right_msb) = bitwise_and(rhs, 0x80000000000000); + let (res) = warp_mul_unsafe56(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100000000000000 - left_msb - right_msb); + if (not_neg == 0x80000000000000){ + let (res) = warp_negate56(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x8000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x8000000000000000); + let (res) = warp_mul_unsafe64(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x10000000000000000 - left_msb - right_msb); + if (not_neg == 0x8000000000000000){ + let (res) = warp_negate64(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x800000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x800000000000000000); + let (res) = warp_mul_unsafe72(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x1000000000000000000 - left_msb - right_msb); + if (not_neg == 0x800000000000000000){ + let (res) = warp_negate72(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x80000000000000000000); + let (res) = warp_mul_unsafe80(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100000000000000000000 - left_msb - right_msb); + if (not_neg == 0x80000000000000000000){ + let (res) = warp_negate80(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x8000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x8000000000000000000000); + let (res) = warp_mul_unsafe88(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x10000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x8000000000000000000000){ + let (res) = warp_negate88(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x800000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x800000000000000000000000); + let (res) = warp_mul_unsafe96(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x1000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x800000000000000000000000){ + let (res) = warp_negate96(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x80000000000000000000000000); + let (res) = warp_mul_unsafe104(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x80000000000000000000000000){ + let (res) = warp_negate104(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000); + let (res) = warp_mul_unsafe112(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x10000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x8000000000000000000000000000){ + let (res) = warp_negate112(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000); + let (res) = warp_mul_unsafe120(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x1000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x800000000000000000000000000000){ + let (res) = warp_negate120(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000); + let (res) = warp_mul_unsafe128(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x80000000000000000000000000000000){ + let (res) = warp_negate128(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000); + let (res) = warp_mul_unsafe136(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x10000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x8000000000000000000000000000000000){ + let (res) = warp_negate136(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000); + let (res) = warp_mul_unsafe144(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x1000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x800000000000000000000000000000000000){ + let (res) = warp_negate144(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000); + let (res) = warp_mul_unsafe152(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x80000000000000000000000000000000000000){ + let (res) = warp_negate152(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe160(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x10000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x8000000000000000000000000000000000000000){ + let (res) = warp_negate160(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe168(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x1000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x800000000000000000000000000000000000000000){ + let (res) = warp_negate168(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe176(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x80000000000000000000000000000000000000000000){ + let (res) = warp_negate176(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe184(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x10000000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x8000000000000000000000000000000000000000000000){ + let (res) = warp_negate184(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe192(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x1000000000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x800000000000000000000000000000000000000000000000){ + let (res) = warp_negate192(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe200(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100000000000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x80000000000000000000000000000000000000000000000000){ + let (res) = warp_negate200(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe208(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x10000000000000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x8000000000000000000000000000000000000000000000000000){ + let (res) = warp_negate208(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe216(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x1000000000000000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x800000000000000000000000000000000000000000000000000000){ + let (res) = warp_negate216(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe224(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100000000000000000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x80000000000000000000000000000000000000000000000000000000){ + let (res) = warp_negate224(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe232(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x10000000000000000000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x8000000000000000000000000000000000000000000000000000000000){ + let (res) = warp_negate232(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe240(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x1000000000000000000000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x800000000000000000000000000000000000000000000000000000000000){ + let (res) = warp_negate240(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local left_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000000000); + let (local right_msb) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000000000); + let (res) = warp_mul_unsafe248(lhs, rhs); + let not_neg = (left_msb + right_msb) * (0x100000000000000000000000000000000000000000000000000000000000000 - left_msb - right_msb); + if (not_neg == 0x80000000000000000000000000000000000000000000000000000000000000){ + let (res) = warp_negate248(res); + return (res,); + }else{ + return (res,); + } +} +func warp_mul_signed_unsafe256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : Uint256, rhs : Uint256) -> (result : Uint256){ + alloc_locals; + let (lhs_nn) = uint256_signed_nn(lhs); + let (local rhs_nn) = uint256_signed_nn(rhs); + let (lhs_abs) = uint256_cond_neg(lhs, lhs_nn); + let (rhs_abs) = uint256_cond_neg(rhs, rhs_nn); + let (res_abs, _) = uint256_mul(lhs_abs, rhs_abs); + let (res) = uint256_cond_neg(res_abs, (lhs_nn + rhs_nn) * (2 - lhs_nn - rhs_nn)); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/mul_unsafe.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/mul_unsafe.cairo new file mode 100644 index 000000000..1b082c6b4 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/mul_unsafe.cairo @@ -0,0 +1,198 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_mul +from warplib.maths.utils import felt_to_uint256 + +func warp_mul_unsafe8{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xff); + return (res,); +} +func warp_mul_unsafe16{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffff); + return (res,); +} +func warp_mul_unsafe24{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffff); + return (res,); +} +func warp_mul_unsafe32{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffff); + return (res,); +} +func warp_mul_unsafe40{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffff); + return (res,); +} +func warp_mul_unsafe48{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffffff); + return (res,); +} +func warp_mul_unsafe56{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffffffff); + return (res,); +} +func warp_mul_unsafe64{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffffffffff); + return (res,); +} +func warp_mul_unsafe72{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffffffffffff); + return (res,); +} +func warp_mul_unsafe80{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffffffffffffff); + return (res,); +} +func warp_mul_unsafe88{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffffffffffffffff); + return (res,); +} +func warp_mul_unsafe96{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_mul_unsafe104{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_mul_unsafe112{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_mul_unsafe120{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + let (res) = bitwise_and(lhs * rhs, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_mul_unsafe128{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0x0); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe136{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe144{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe152{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe160{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe168{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe176{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe184{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe192{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe200{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe208{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffffffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe216{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffffffffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe224{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffffffffffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe232{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffffffffffffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe240{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffffffffffffffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe248{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (l256 : Uint256) = felt_to_uint256(lhs); + let (r256 : Uint256) = felt_to_uint256(rhs); + let (local res : Uint256, _) = uint256_mul(l256, r256); + let (high) = bitwise_and(res.high, 0xffffffffffffffffffffffffffffff); + return (res.low + 0x100000000000000000000000000000000 * high,); +} +func warp_mul_unsafe256{range_check_ptr}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + let (res : Uint256, _) = uint256_mul(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/mulmod.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/mulmod.cairo new file mode 100644 index 000000000..6835b38a7 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/mulmod.cairo @@ -0,0 +1,38 @@ +from starkware.cairo.common.uint256 import ( + Uint256, + uint256_unsigned_div_rem, + uint256_add, + uint256_mul, + uint256_sub, + ALL_ONES, +) +from warplib.maths.utils import felt_to_uint256 +from warplib.maths.addmod import warp_addmod + +func warp_mulmod{range_check_ptr}(x: Uint256, y: Uint256, k: Uint256) -> (res: Uint256) { + alloc_locals; + if (k.high + k.low == 0) { + with_attr error_message("Modulo by zero error") { + assert 1 = 0; + } + } + + let (xy_low, xy_high) = uint256_mul(x, y); + if (xy_high.low + xy_high.high == 0) { + let (_, res) = uint256_unsigned_div_rem(xy_low, k); + return (res,); + } + + let uint256_MAX = Uint256(low=ALL_ONES, high=ALL_ONES); + let (_, exp_mod_k) = uint256_unsigned_div_rem(uint256_MAX, k); + let (exp_mod_k, _) = uint256_add(exp_mod_k, Uint256(1, 0)); + let (_, exp_mod_k) = uint256_unsigned_div_rem(exp_mod_k, k); + + let (_, xy_high_mod_k) = uint256_unsigned_div_rem(xy_high, k); + let (_, xy_low_mod_k) = uint256_unsigned_div_rem(xy_low, k); + + let (xy_high_exp_mod_k) = warp_mulmod(exp_mod_k, xy_high_mod_k, k); + let (res) = warp_addmod(xy_high_exp_mod_k, xy_low_mod_k, k); + + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/negate.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/negate.cairo new file mode 100644 index 000000000..3e88ea589 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/negate.cairo @@ -0,0 +1,164 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_neg + +func warp_negate8{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100 - op; + let (res) = bitwise_and(raw_res, 0xff); + return (res,); +} +func warp_negate16{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x10000 - op; + let (res) = bitwise_and(raw_res, 0xffff); + return (res,); +} +func warp_negate24{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x1000000 - op; + let (res) = bitwise_and(raw_res, 0xffffff); + return (res,); +} +func warp_negate32{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffff); + return (res,); +} +func warp_negate40{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x10000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffff); + return (res,); +} +func warp_negate48{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x1000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffff); + return (res,); +} +func warp_negate56{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffff); + return (res,); +} +func warp_negate64{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x10000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffff); + return (res,); +} +func warp_negate72{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x1000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffff); + return (res,); +} +func warp_negate80{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffff); + return (res,); +} +func warp_negate88{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x10000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffff); + return (res,); +} +func warp_negate96{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x1000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_negate104{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_negate112{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x10000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate120{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x1000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate128{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate136{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x10000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate144{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x1000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate152{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate160{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x10000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate168{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x1000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate176{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate184{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x10000000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate192{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x1000000000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate200{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100000000000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate208{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x10000000000000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate216{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x1000000000000000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate224{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100000000000000000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate232{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x10000000000000000000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate240{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x1000000000000000000000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate248{bitwise_ptr : BitwiseBuiltin*}(op : felt) -> (res : felt){ + let raw_res = 0x100000000000000000000000000000000000000000000000000000000000000 - op; + let (res) = bitwise_and(raw_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_negate256{range_check_ptr}(op : Uint256) -> (res : Uint256){ + let (res) = uint256_neg(op); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/neq.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/neq.cairo new file mode 100644 index 000000000..8a04eef18 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/neq.cairo @@ -0,0 +1,14 @@ +from starkware.cairo.common.uint256 import Uint256, uint256_eq + +func warp_neq(lhs: felt, rhs: felt) -> (res: felt) { + if (lhs == rhs) { + return (0,); + } else { + return (1,); + } +} + +func warp_neq256{range_check_ptr}(lhs: Uint256, rhs: Uint256) -> (res: felt) { + let (res: felt) = uint256_eq(lhs, rhs); + return (1 - res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/or.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/or.cairo new file mode 100644 index 000000000..96fef5e4f --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/or.cairo @@ -0,0 +1,7 @@ +func warp_or(lhs: felt, rhs: felt) -> (res: felt) { + let val = lhs + rhs; + if (val == 0) { + return (0,); + } + return (1,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/pow2.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/pow2.cairo new file mode 100644 index 000000000..98da0afee --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/pow2.cairo @@ -0,0 +1,267 @@ +from starkware.cairo.common.uint256 import Uint256 +from starkware.cairo.common.registers import get_label_location +from warplib.maths.utils import felt_to_uint256 + +func pow2(i) -> (res: felt) { + let (data_address) = get_label_location(data); + return ([data_address + i],); + + data: + dw 0x1; + dw 0x2; + dw 0x4; + dw 0x8; + dw 0x10; + dw 0x20; + dw 0x40; + dw 0x80; + dw 0x100; + dw 0x200; + dw 0x400; + dw 0x800; + dw 0x1000; + dw 0x2000; + dw 0x4000; + dw 0x8000; + dw 0x10000; + dw 0x20000; + dw 0x40000; + dw 0x80000; + dw 0x100000; + dw 0x200000; + dw 0x400000; + dw 0x800000; + dw 0x1000000; + dw 0x2000000; + dw 0x4000000; + dw 0x8000000; + dw 0x10000000; + dw 0x20000000; + dw 0x40000000; + dw 0x80000000; + dw 0x100000000; + dw 0x200000000; + dw 0x400000000; + dw 0x800000000; + dw 0x1000000000; + dw 0x2000000000; + dw 0x4000000000; + dw 0x8000000000; + dw 0x10000000000; + dw 0x20000000000; + dw 0x40000000000; + dw 0x80000000000; + dw 0x100000000000; + dw 0x200000000000; + dw 0x400000000000; + dw 0x800000000000; + dw 0x1000000000000; + dw 0x2000000000000; + dw 0x4000000000000; + dw 0x8000000000000; + dw 0x10000000000000; + dw 0x20000000000000; + dw 0x40000000000000; + dw 0x80000000000000; + dw 0x100000000000000; + dw 0x200000000000000; + dw 0x400000000000000; + dw 0x800000000000000; + dw 0x1000000000000000; + dw 0x2000000000000000; + dw 0x4000000000000000; + dw 0x8000000000000000; + dw 0x10000000000000000; + dw 0x20000000000000000; + dw 0x40000000000000000; + dw 0x80000000000000000; + dw 0x100000000000000000; + dw 0x200000000000000000; + dw 0x400000000000000000; + dw 0x800000000000000000; + dw 0x1000000000000000000; + dw 0x2000000000000000000; + dw 0x4000000000000000000; + dw 0x8000000000000000000; + dw 0x10000000000000000000; + dw 0x20000000000000000000; + dw 0x40000000000000000000; + dw 0x80000000000000000000; + dw 0x100000000000000000000; + dw 0x200000000000000000000; + dw 0x400000000000000000000; + dw 0x800000000000000000000; + dw 0x1000000000000000000000; + dw 0x2000000000000000000000; + dw 0x4000000000000000000000; + dw 0x8000000000000000000000; + dw 0x10000000000000000000000; + dw 0x20000000000000000000000; + dw 0x40000000000000000000000; + dw 0x80000000000000000000000; + dw 0x100000000000000000000000; + dw 0x200000000000000000000000; + dw 0x400000000000000000000000; + dw 0x800000000000000000000000; + dw 0x1000000000000000000000000; + dw 0x2000000000000000000000000; + dw 0x4000000000000000000000000; + dw 0x8000000000000000000000000; + dw 0x10000000000000000000000000; + dw 0x20000000000000000000000000; + dw 0x40000000000000000000000000; + dw 0x80000000000000000000000000; + dw 0x100000000000000000000000000; + dw 0x200000000000000000000000000; + dw 0x400000000000000000000000000; + dw 0x800000000000000000000000000; + dw 0x1000000000000000000000000000; + dw 0x2000000000000000000000000000; + dw 0x4000000000000000000000000000; + dw 0x8000000000000000000000000000; + dw 0x10000000000000000000000000000; + dw 0x20000000000000000000000000000; + dw 0x40000000000000000000000000000; + dw 0x80000000000000000000000000000; + dw 0x100000000000000000000000000000; + dw 0x200000000000000000000000000000; + dw 0x400000000000000000000000000000; + dw 0x800000000000000000000000000000; + dw 0x1000000000000000000000000000000; + dw 0x2000000000000000000000000000000; + dw 0x4000000000000000000000000000000; + dw 0x8000000000000000000000000000000; + dw 0x10000000000000000000000000000000; + dw 0x20000000000000000000000000000000; + dw 0x40000000000000000000000000000000; + dw 0x80000000000000000000000000000000; + dw 0x100000000000000000000000000000000; + dw 0x200000000000000000000000000000000; + dw 0x400000000000000000000000000000000; + dw 0x800000000000000000000000000000000; + dw 0x1000000000000000000000000000000000; + dw 0x2000000000000000000000000000000000; + dw 0x4000000000000000000000000000000000; + dw 0x8000000000000000000000000000000000; + dw 0x10000000000000000000000000000000000; + dw 0x20000000000000000000000000000000000; + dw 0x40000000000000000000000000000000000; + dw 0x80000000000000000000000000000000000; + dw 0x100000000000000000000000000000000000; + dw 0x200000000000000000000000000000000000; + dw 0x400000000000000000000000000000000000; + dw 0x800000000000000000000000000000000000; + dw 0x1000000000000000000000000000000000000; + dw 0x2000000000000000000000000000000000000; + dw 0x4000000000000000000000000000000000000; + dw 0x8000000000000000000000000000000000000; + dw 0x10000000000000000000000000000000000000; + dw 0x20000000000000000000000000000000000000; + dw 0x40000000000000000000000000000000000000; + dw 0x80000000000000000000000000000000000000; + dw 0x100000000000000000000000000000000000000; + dw 0x200000000000000000000000000000000000000; + dw 0x400000000000000000000000000000000000000; + dw 0x800000000000000000000000000000000000000; + dw 0x1000000000000000000000000000000000000000; + dw 0x2000000000000000000000000000000000000000; + dw 0x4000000000000000000000000000000000000000; + dw 0x8000000000000000000000000000000000000000; + dw 0x10000000000000000000000000000000000000000; + dw 0x20000000000000000000000000000000000000000; + dw 0x40000000000000000000000000000000000000000; + dw 0x80000000000000000000000000000000000000000; + dw 0x100000000000000000000000000000000000000000; + dw 0x200000000000000000000000000000000000000000; + dw 0x400000000000000000000000000000000000000000; + dw 0x800000000000000000000000000000000000000000; + dw 0x1000000000000000000000000000000000000000000; + dw 0x2000000000000000000000000000000000000000000; + dw 0x4000000000000000000000000000000000000000000; + dw 0x8000000000000000000000000000000000000000000; + dw 0x10000000000000000000000000000000000000000000; + dw 0x20000000000000000000000000000000000000000000; + dw 0x40000000000000000000000000000000000000000000; + dw 0x80000000000000000000000000000000000000000000; + dw 0x100000000000000000000000000000000000000000000; + dw 0x200000000000000000000000000000000000000000000; + dw 0x400000000000000000000000000000000000000000000; + dw 0x800000000000000000000000000000000000000000000; + dw 0x1000000000000000000000000000000000000000000000; + dw 0x2000000000000000000000000000000000000000000000; + dw 0x4000000000000000000000000000000000000000000000; + dw 0x8000000000000000000000000000000000000000000000; + dw 0x10000000000000000000000000000000000000000000000; + dw 0x20000000000000000000000000000000000000000000000; + dw 0x40000000000000000000000000000000000000000000000; + dw 0x80000000000000000000000000000000000000000000000; + dw 0x100000000000000000000000000000000000000000000000; + dw 0x200000000000000000000000000000000000000000000000; + dw 0x400000000000000000000000000000000000000000000000; + dw 0x800000000000000000000000000000000000000000000000; + dw 0x1000000000000000000000000000000000000000000000000; + dw 0x2000000000000000000000000000000000000000000000000; + dw 0x4000000000000000000000000000000000000000000000000; + dw 0x8000000000000000000000000000000000000000000000000; + dw 0x10000000000000000000000000000000000000000000000000; + dw 0x20000000000000000000000000000000000000000000000000; + dw 0x40000000000000000000000000000000000000000000000000; + dw 0x80000000000000000000000000000000000000000000000000; + dw 0x100000000000000000000000000000000000000000000000000; + dw 0x200000000000000000000000000000000000000000000000000; + dw 0x400000000000000000000000000000000000000000000000000; + dw 0x800000000000000000000000000000000000000000000000000; + dw 0x1000000000000000000000000000000000000000000000000000; + dw 0x2000000000000000000000000000000000000000000000000000; + dw 0x4000000000000000000000000000000000000000000000000000; + dw 0x8000000000000000000000000000000000000000000000000000; + dw 0x10000000000000000000000000000000000000000000000000000; + dw 0x20000000000000000000000000000000000000000000000000000; + dw 0x40000000000000000000000000000000000000000000000000000; + dw 0x80000000000000000000000000000000000000000000000000000; + dw 0x100000000000000000000000000000000000000000000000000000; + dw 0x200000000000000000000000000000000000000000000000000000; + dw 0x400000000000000000000000000000000000000000000000000000; + dw 0x800000000000000000000000000000000000000000000000000000; + dw 0x1000000000000000000000000000000000000000000000000000000; + dw 0x2000000000000000000000000000000000000000000000000000000; + dw 0x4000000000000000000000000000000000000000000000000000000; + dw 0x8000000000000000000000000000000000000000000000000000000; + dw 0x10000000000000000000000000000000000000000000000000000000; + dw 0x20000000000000000000000000000000000000000000000000000000; + dw 0x40000000000000000000000000000000000000000000000000000000; + dw 0x80000000000000000000000000000000000000000000000000000000; + dw 0x100000000000000000000000000000000000000000000000000000000; + dw 0x200000000000000000000000000000000000000000000000000000000; + dw 0x400000000000000000000000000000000000000000000000000000000; + dw 0x800000000000000000000000000000000000000000000000000000000; + dw 0x1000000000000000000000000000000000000000000000000000000000; + dw 0x2000000000000000000000000000000000000000000000000000000000; + dw 0x4000000000000000000000000000000000000000000000000000000000; + dw 0x8000000000000000000000000000000000000000000000000000000000; + dw 0x10000000000000000000000000000000000000000000000000000000000; + dw 0x20000000000000000000000000000000000000000000000000000000000; + dw 0x40000000000000000000000000000000000000000000000000000000000; + dw 0x80000000000000000000000000000000000000000000000000000000000; + dw 0x100000000000000000000000000000000000000000000000000000000000; + dw 0x200000000000000000000000000000000000000000000000000000000000; + dw 0x400000000000000000000000000000000000000000000000000000000000; + dw 0x800000000000000000000000000000000000000000000000000000000000; + dw 0x1000000000000000000000000000000000000000000000000000000000000; + dw 0x2000000000000000000000000000000000000000000000000000000000000; + dw 0x4000000000000000000000000000000000000000000000000000000000000; + dw 0x8000000000000000000000000000000000000000000000000000000000000; + dw 0x10000000000000000000000000000000000000000000000000000000000000; + dw 0x20000000000000000000000000000000000000000000000000000000000000; + dw 0x40000000000000000000000000000000000000000000000000000000000000; + dw 0x80000000000000000000000000000000000000000000000000000000000000; + dw 0x100000000000000000000000000000000000000000000000000000000000000; + dw 0x200000000000000000000000000000000000000000000000000000000000000; + dw 0x400000000000000000000000000000000000000000000000000000000000000; +} + +func u256_pow2{range_check_ptr}(i) -> (res: Uint256) { + let (felt_pow2) = pow2(i); + let (res) = felt_to_uint256(felt_pow2); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/shl.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/shl.cairo new file mode 100644 index 000000000..db4520410 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/shl.cairo @@ -0,0 +1,730 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.math import split_felt +from starkware.cairo.common.math_cmp import is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_shl +from warplib.maths.pow2 import pow2 + +func warp_shl8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(8, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 8 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl8_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl8(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(16, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 16 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl16_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl16(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(24, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 24 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl24_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl24(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(32, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 32 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl32_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl32(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(40, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 40 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl40_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl40(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(48, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 48 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl48_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl48(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(56, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 56 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl56_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl56(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(64, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 64 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl64_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl64(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(72, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 72 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl72_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl72(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(80, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 80 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl80_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl80(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(88, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 88 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl88_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl88(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(96, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 96 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl96_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl96(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(104, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 104 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl104_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl104(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(112, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 112 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl112_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl112(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(120, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 120 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl120_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl120(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(128, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 128 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl128_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl128(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(136, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 136 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl136_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl136(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(144, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 144 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl144_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl144(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(152, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 152 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl152_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl152(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(160, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 160 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl160_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl160(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(168, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 168 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl168_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl168(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(176, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 176 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl176_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl176(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(184, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 184 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl184_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl184(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(192, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 192 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl192_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl192(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(200, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 200 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl200_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl200(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(208, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 208 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl208_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl208(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(216, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 216 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl216_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl216(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(224, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 224 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl224_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl224(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(232, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 232 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl232_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl232(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(240, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 240 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl240_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl240(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // width <= rhs (shift amount) means result will be 0 + let large_shift = is_le_felt(248, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 248 - rhs; + let (preserved_bound) = pow2(preserved_width); + let (lhs_truncated) = bitwise_and(lhs, preserved_bound - 1); + let (multiplier) = pow2(rhs); + return (lhs_truncated * multiplier,); + } +} +func warp_shl248_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shl248(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shl256{range_check_ptr}(lhs : Uint256, rhs : felt) -> (result : Uint256){ + let (high, low) = split_felt(rhs); + let (res) = uint256_shl(lhs, Uint256(low, high)); + return (res,); +} +func warp_shl256_256{range_check_ptr}(lhs : Uint256, rhs : Uint256) -> (result : Uint256){ + let (res) = uint256_shl(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/shr.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/shr.cairo new file mode 100644 index 000000000..efe3c350c --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/shr.cairo @@ -0,0 +1,808 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and, bitwise_not +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.math_cmp import is_le, is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_and +from warplib.maths.pow2 import pow2 + +func warp_shr8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(8, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 8 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr8_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr8(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(16, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 16 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr16_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr16(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(24, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 24 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr24_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr24(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(32, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 32 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr32_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr32(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(40, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 40 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr40_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr40(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(48, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 48 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr48_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr48(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(56, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 56 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr56_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr56(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(64, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 64 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr64_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr64(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(72, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 72 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr72_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr72(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(80, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 80 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr80_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr80(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(88, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 88 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr88_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr88(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(96, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 96 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr96_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr96(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(104, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 104 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr104_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr104(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(112, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 112 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr112_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr112(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(120, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 120 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr120_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr120(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(128, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 128 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr128_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr128(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(136, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 136 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr136_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr136(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(144, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 144 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr144_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr144(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(152, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 152 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr152_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr152(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(160, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 160 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr160_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr160(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(168, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 168 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr168_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr168(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(176, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 176 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr176_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr176(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(184, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 184 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr184_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr184(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(192, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 192 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr192_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr192(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(200, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 200 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr200_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr200(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(208, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 208 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr208_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr208(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(216, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 216 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr216_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr216(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(224, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 224 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr224_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr224(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(232, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 232 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr232_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr232(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(240, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 240 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr240_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr240(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + let large_shift = is_le_felt(248, rhs); + if (large_shift == 1){ + return (0,); + }else{ + let preserved_width = 248 - rhs; + let (preserved_bound) = pow2(preserved_width); + let mask = preserved_bound - 1; + let (divisor) = pow2(rhs); + let shifted_mask = mask * divisor; + let (lhs_truncated) = bitwise_and(lhs, shifted_mask); + return (lhs_truncated / divisor , ); + } +} +func warp_shr248_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res,) = warp_shr248(lhs, rhs.low); + return (res,); + }else{ + return (0,); + } +} +func warp_shr256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : felt) -> ( + result : Uint256){ + let le_127 = is_le(rhs, 127); + if (le_127 == 1){ + // (h', l') := (h, l) >> rhs + // p := 2^rhs + // l' = ((h & (p-1)) << (128 - rhs)) + ((l&~(p-1)) >> rhs) + // = ((h & (p-1)) << 128 >> rhs) + ((l&~(p-1)) >> rhs) + // = (h & (p-1)) * 2^128 / p + (l&~(p-1)) / p + // = (h & (p-1) * 2^128 + l&~(p-1)) / p + // h' = h >> rhs = (h - h&(p-1)) / p + let (p) = pow2(rhs); + let (low_mask) = bitwise_not(p - 1); + let (low_part) = bitwise_and(lhs.low, low_mask); + let (high_part) = bitwise_and(lhs.high, p - 1); + return ( + Uint256(low=(low_part + 0x100000000000000000000000000000000 * high_part) / p, high=(lhs.high - high_part) / p),); + } + let le_255 = is_le(rhs, 255); + if (le_255 == 1){ + let (p) = pow2(rhs - 128); + let (mask) = bitwise_not(p - 1); + let (res) = bitwise_and(lhs.high, mask); + return (Uint256(res / p, 0),); + } + return (Uint256(0, 0),); +} +func warp_shr256_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : Uint256) -> ( + result : Uint256){ + if (rhs.high != 0){ + return (Uint256(0, 0),); + } + let le_127 = is_le(rhs.low, 127); + if (le_127 == 1){ + // (h', l') := (h, l) >> rhs + // p := 2^rhs + // l' = ((h & (p-1)) << (128 - rhs)) + ((l&~(p-1)) >> rhs) + // = ((h & (p-1)) << 128 >> rhs) + ((l&~(p-1)) >> rhs) + // = (h & (p-1)) * 2^128 / p + (l&~(p-1)) / p + // = (h & (p-1) * 2^128 + l&~(p-1)) / p + // h' = h >> rhs = (h - h&(p-1)) / p + let (p) = pow2(rhs.low); + let (low_mask) = bitwise_not(p - 1); + let (low_part) = bitwise_and(lhs.low, low_mask); + let (high_part) = bitwise_and(lhs.high, p - 1); + return ( + Uint256(low=(low_part + 0x100000000000000000000000000000000 * high_part) / p, high=(lhs.high - high_part) / p),); + } + let le_255 = is_le(rhs.low, 255); + if (le_255 == 1){ + let (p) = pow2(rhs.low - 128); + let (mask) = bitwise_not(p - 1); + let (res) = bitwise_and(lhs.high, mask); + return (Uint256(res / p, 0),); + } + return (Uint256(0, 0),); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/shr_signed.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/shr_signed.cairo new file mode 100644 index 000000000..0121a3000 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/shr_signed.cairo @@ -0,0 +1,1004 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.math_cmp import is_le, is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_and +from warplib.maths.pow2 import pow2 +from warplib.maths.shr import warp_shr8, warp_shr16, warp_shr24, warp_shr32, warp_shr40, warp_shr48, warp_shr56, warp_shr64, warp_shr72, warp_shr80, warp_shr88, warp_shr96, warp_shr104, warp_shr112, warp_shr120, warp_shr128, warp_shr136, warp_shr144, warp_shr152, warp_shr160, warp_shr168, warp_shr176, warp_shr184, warp_shr192, warp_shr200, warp_shr208, warp_shr216, warp_shr224, warp_shr232, warp_shr240, warp_shr248, warp_shr256 + +func warp_shr_signed8{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr8(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(8, rhs); + if (large_shift == 1){ + return (0xff,); + }else{ + let (shifted) = warp_shr8(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(8 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed8_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr8(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr8(lhs, 8); + return (res,); + } +} +func warp_shr_signed16{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x8000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr16(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(16, rhs); + if (large_shift == 1){ + return (0xffff,); + }else{ + let (shifted) = warp_shr16(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(16 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed16_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr16(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr16(lhs, 16); + return (res,); + } +} +func warp_shr_signed24{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x800000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr24(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(24, rhs); + if (large_shift == 1){ + return (0xffffff,); + }else{ + let (shifted) = warp_shr24(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(24 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed24_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr24(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr24(lhs, 24); + return (res,); + } +} +func warp_shr_signed32{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr32(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(32, rhs); + if (large_shift == 1){ + return (0xffffffff,); + }else{ + let (shifted) = warp_shr32(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(32 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed32_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr32(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr32(lhs, 32); + return (res,); + } +} +func warp_shr_signed40{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x8000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr40(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(40, rhs); + if (large_shift == 1){ + return (0xffffffffff,); + }else{ + let (shifted) = warp_shr40(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(40 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed40_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr40(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr40(lhs, 40); + return (res,); + } +} +func warp_shr_signed48{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x800000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr48(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(48, rhs); + if (large_shift == 1){ + return (0xffffffffffff,); + }else{ + let (shifted) = warp_shr48(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(48 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed48_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr48(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr48(lhs, 48); + return (res,); + } +} +func warp_shr_signed56{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr56(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(56, rhs); + if (large_shift == 1){ + return (0xffffffffffffff,); + }else{ + let (shifted) = warp_shr56(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(56 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed56_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr56(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr56(lhs, 56); + return (res,); + } +} +func warp_shr_signed64{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x8000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr64(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(64, rhs); + if (large_shift == 1){ + return (0xffffffffffffffff,); + }else{ + let (shifted) = warp_shr64(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(64 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed64_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr64(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr64(lhs, 64); + return (res,); + } +} +func warp_shr_signed72{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x800000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr72(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(72, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffff,); + }else{ + let (shifted) = warp_shr72(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(72 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed72_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr72(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr72(lhs, 72); + return (res,); + } +} +func warp_shr_signed80{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr80(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(80, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr80(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(80 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed80_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr80(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr80(lhs, 80); + return (res,); + } +} +func warp_shr_signed88{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x8000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr88(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(88, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr88(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(88 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed88_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr88(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr88(lhs, 88); + return (res,); + } +} +func warp_shr_signed96{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x800000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr96(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(96, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr96(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(96 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed96_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr96(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr96(lhs, 96); + return (res,); + } +} +func warp_shr_signed104{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr104(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(104, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr104(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(104 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed104_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr104(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr104(lhs, 104); + return (res,); + } +} +func warp_shr_signed112{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x8000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr112(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(112, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr112(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(112 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed112_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr112(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr112(lhs, 112); + return (res,); + } +} +func warp_shr_signed120{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x800000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr120(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(120, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr120(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(120 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed120_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr120(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr120(lhs, 120); + return (res,); + } +} +func warp_shr_signed128{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr128(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(128, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr128(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(128 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed128_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr128(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr128(lhs, 128); + return (res,); + } +} +func warp_shr_signed136{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr136(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(136, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr136(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(136 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed136_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr136(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr136(lhs, 136); + return (res,); + } +} +func warp_shr_signed144{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr144(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(144, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr144(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(144 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed144_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr144(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr144(lhs, 144); + return (res,); + } +} +func warp_shr_signed152{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr152(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(152, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr152(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(152 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed152_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr152(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr152(lhs, 152); + return (res,); + } +} +func warp_shr_signed160{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr160(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(160, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr160(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(160 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed160_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr160(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr160(lhs, 160); + return (res,); + } +} +func warp_shr_signed168{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr168(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(168, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr168(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(168 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed168_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr168(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr168(lhs, 168); + return (res,); + } +} +func warp_shr_signed176{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr176(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(176, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr176(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(176 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed176_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr176(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr176(lhs, 176); + return (res,); + } +} +func warp_shr_signed184{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr184(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(184, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr184(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(184 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed184_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr184(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr184(lhs, 184); + return (res,); + } +} +func warp_shr_signed192{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr192(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(192, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr192(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(192 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed192_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr192(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr192(lhs, 192); + return (res,); + } +} +func warp_shr_signed200{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr200(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(200, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr200(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(200 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed200_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr200(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr200(lhs, 200); + return (res,); + } +} +func warp_shr_signed208{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr208(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(208, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr208(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(208 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed208_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr208(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr208(lhs, 208); + return (res,); + } +} +func warp_shr_signed216{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr216(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(216, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr216(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(216 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed216_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr216(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr216(lhs, 216); + return (res,); + } +} +func warp_shr_signed224{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr224(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(224, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr224(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(224 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed224_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr224(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr224(lhs, 224); + return (res,); + } +} +func warp_shr_signed232{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr232(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(232, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr232(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(232 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed232_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr232(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr232(lhs, 232); + return (res,); + } +} +func warp_shr_signed240{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr240(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(240, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr240(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(240 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed240_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr240(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr240(lhs, 240); + return (res,); + } +} +func warp_shr_signed248{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000000000); + local bitwise_ptr : BitwiseBuiltin* = bitwise_ptr; + if (lhs_msb == 0){ + let (res) = warp_shr248(lhs, rhs); + return (res,); + }else{ + let large_shift = is_le_felt(248, rhs); + if (large_shift == 1){ + return (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff,); + }else{ + let (shifted) = warp_shr248(lhs, rhs); + let (sign_extend_bound) = pow2(rhs); + let sign_extend_value = sign_extend_bound - 1; + let (sign_extend_multiplier) = pow2(248 - rhs); + return (shifted + sign_extend_value * sign_extend_multiplier,); + } + } +} +func warp_shr_signed248_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : Uint256) -> (res : felt){ + if (rhs.high == 0){ + let (res) = warp_shr248(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr248(lhs, 248); + return (res,); + } +} +func warp_shr_signed256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : felt) -> (res : Uint256){ + alloc_locals; + let (local lhs_msb) = bitwise_and(lhs.high, 0x80000000000000000000000000000000); + let (logical_shift) = warp_shr256(lhs, rhs); + if (lhs_msb == 0){ + return (logical_shift,); + }else{ + let large_shift = is_le(256, rhs); + if (large_shift == 1){ + return (Uint256(0xffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffff),); + }else{ + let crosses_boundary = is_le(128, rhs); + if (crosses_boundary == 1){ + let (bound) = pow2(rhs-128); + let ones = bound - 1; + let (shift) = pow2(256-rhs); + return (Uint256(logical_shift.low+ones*shift, 0xffffffffffffffffffffffffffffffff),); + }else{ + let (bound) = pow2(rhs); + let ones = bound - 1; + let (shift) = pow2(128-rhs); + return (Uint256(logical_shift.low, logical_shift.high+ones*shift),); + } + } + } +} +func warp_shr_signed256_256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + if (rhs.high == 0){ + let (res) = warp_shr_signed256(lhs, rhs.low); + return (res,); + }else{ + let (res) = warp_shr_signed256(lhs, 256); + return (res,); + } +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/sub.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/sub.cairo new file mode 100644 index 000000000..822a6e921 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/sub.cairo @@ -0,0 +1,30 @@ +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.math_cmp import is_le_felt +from starkware.cairo.common.uint256 import Uint256, uint256_le + +func warp_sub{range_check_ptr}(lhs: felt, rhs: felt) -> (res: felt) { + let valid = is_le_felt(rhs, lhs); + assert valid = 1; + return (lhs - rhs,); +} + +const MASK128 = 2 ** 128 - 1; +const BOUND128 = 2 ** 128; + +func warp_sub256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs: Uint256, rhs: Uint256) -> ( + res: Uint256 +) { + let (safe) = uint256_le(rhs, lhs); + assert safe = 1; + // preemptively borrow from bit128 + let (low_safe) = bitwise_and(BOUND128 + lhs.low - rhs.low, MASK128); + let low_unsafe = lhs.low - rhs.low; + if (low_safe == low_unsafe) { + // the borrow was not used + return (Uint256(low_safe, lhs.high - rhs.high),); + } else { + // the borrow was used + return (Uint256(low_safe, lhs.high - rhs.high - 1),); + } +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/sub_signed.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/sub_signed.cairo new file mode 100644 index 000000000..2df5815ec --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/sub_signed.cairo @@ -0,0 +1,648 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_add, uint256_signed_le, uint256_sub, uint256_not + +func warp_sub_signed8{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80); + let (right_msb : felt) = bitwise_and(rhs, 0x80); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180); + assert overflowBits * (overflowBits - 0x180) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xff); + return (res,); +} +func warp_sub_signed16{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x18000); + assert overflowBits * (overflowBits - 0x18000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffff); + return (res,); +} +func warp_sub_signed24{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x1800000); + assert overflowBits * (overflowBits - 0x1800000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffff); + return (res,); +} +func warp_sub_signed32{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180000000); + assert overflowBits * (overflowBits - 0x180000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffff); + return (res,); +} +func warp_sub_signed40{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x18000000000); + assert overflowBits * (overflowBits - 0x18000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffff); + return (res,); +} +func warp_sub_signed48{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x1800000000000); + assert overflowBits * (overflowBits - 0x1800000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffff); + return (res,); +} +func warp_sub_signed56{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180000000000000); + assert overflowBits * (overflowBits - 0x180000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffff); + return (res,); +} +func warp_sub_signed64{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x18000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffff); + return (res,); +} +func warp_sub_signed72{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x1800000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffff); + return (res,); +} +func warp_sub_signed80{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffff); + return (res,); +} +func warp_sub_signed88{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x18000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed96{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x1800000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed104{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed112{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x18000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed120{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x1800000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed128{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed136{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x18000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed144{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x1800000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed152{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed160{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x18000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed168{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x1800000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed176{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed184{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x18000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed192{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x1800000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed200{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed208{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x18000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed216{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x1800000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed224{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180000000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed232{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x18000000000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x18000000000000000000000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed240{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x1800000000000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x1800000000000000000000000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed248{bitwise_ptr : BitwiseBuiltin*}(lhs : felt, rhs : felt) -> ( + res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Check if the result fits in the correct width + let (overflowBits) = bitwise_and(extended_res, 0x180000000000000000000000000000000000000000000000000000000000000); + assert overflowBits * (overflowBits - 0x180000000000000000000000000000000000000000000000000000000000000) = 0; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed256{range_check_ptr, bitwise_ptr : BitwiseBuiltin*}(lhs : Uint256, rhs : Uint256) -> ( + res : Uint256){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs.high, 0x80000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs.high, 0x80000000000000000000000000000000); + let left_overflow : felt = left_msb / 0x80000000000000000000000000000000; + let right_overflow : felt = right_msb / 0x80000000000000000000000000000000; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let (right_flipped : Uint256) = uint256_not(rhs); + let (right_neg, overflow) = uint256_add(right_flipped, Uint256(1,0)); + let right_overflow_neg = overflow + 1 - right_overflow; + let (res, res_base_overflow) = uint256_add(lhs, right_neg); + let res_overflow = res_base_overflow + left_overflow + right_overflow_neg; + + // Check if the result fits in the correct width + let (res_msb : felt) = bitwise_and(res.high, 0x80000000000000000000000000000000); + let (res_overflow_lsb : felt) = bitwise_and(res_overflow, 1); + assert res_overflow_lsb * 0x80000000000000000000000000000000 = res_msb; + + // Narrow and return + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/sub_signed_unsafe.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/sub_signed_unsafe.cairo new file mode 100644 index 000000000..db1ff5cc1 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/sub_signed_unsafe.cairo @@ -0,0 +1,505 @@ +//AUTO-GENERATED +from starkware.cairo.common.bitwise import bitwise_and +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_sub + +func warp_sub_signed_unsafe8{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80); + let (right_msb : felt) = bitwise_and(rhs, 0x80); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xff); + return (res,); +} +func warp_sub_signed_unsafe16{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffff); + return (res,); +} +func warp_sub_signed_unsafe24{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffff); + return (res,); +} +func warp_sub_signed_unsafe32{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffff); + return (res,); +} +func warp_sub_signed_unsafe40{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffff); + return (res,); +} +func warp_sub_signed_unsafe48{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe56{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe64{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe72{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe80{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe88{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe96{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe104{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe112{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe120{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe128{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe136{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe144{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe152{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe160{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe168{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe176{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe184{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe192{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe200{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe208{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe216{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe224{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe232{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x8000000000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x8000000000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x20000000000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe240{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x800000000000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x800000000000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x2000000000000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe248{bitwise_ptr : BitwiseBuiltin*}( + lhs : felt, rhs : felt) -> (res : felt){ + // First sign extend both operands + let (left_msb : felt) = bitwise_and(lhs, 0x80000000000000000000000000000000000000000000000000000000000000); + let (right_msb : felt) = bitwise_and(rhs, 0x80000000000000000000000000000000000000000000000000000000000000); + let left_safe : felt = lhs + 2 * left_msb; + let right_safe : felt = rhs + 2 * right_msb; + + // Now safely negate the rhs and add (l - r = l + (-r)) + let right_neg : felt = 0x200000000000000000000000000000000000000000000000000000000000000 - right_safe; + let extended_res : felt = left_safe + right_neg; + + // Narrow and return + let (res) = bitwise_and(extended_res, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); + return (res,); +} +func warp_sub_signed_unsafe256{range_check_ptr}(lhs : Uint256, rhs : Uint256) -> (res : Uint256){ + let (res) = uint256_sub(lhs, rhs); + return (res,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/sub_unsafe.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/sub_unsafe.cairo new file mode 100644 index 000000000..0dcd8e0ca --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/sub_unsafe.cairo @@ -0,0 +1,100 @@ +//AUTO-GENERATED +use integer::u256_overflow_sub; + +fn warp_sub_unsafe8(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe16(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe24(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe32(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe40(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe48(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe56(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe64(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe72(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe80(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe88(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe96(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe104(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe112(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe120(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe128(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe136(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe144(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe152(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe160(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe168(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe176(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe184(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe192(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe200(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe208(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe216(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe224(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe232(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe240(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe248(lhs : felt, rhs : felt) -> felt { + return lhs - rhs; +} +fn warp_sub_unsafe256(lhs : u256, rhs : u256) -> u256 { + let (value, _) = u256_overflow_sub(lhs, rhs); + return value; +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/utils.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/utils.cairo new file mode 100644 index 000000000..004b14d81 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/utils.cairo @@ -0,0 +1,72 @@ +from starkware.cairo.common.math import split_felt, unsigned_div_rem +from starkware.cairo.common.math_cmp import is_le +from starkware.cairo.common.uint256 import Uint256, uint256_le + +func get_max{range_check_ptr}(op1, op2) -> (result: felt) { + let le = is_le(op1, op2); + if (le == 1) { + return (op2,); + } else { + return (op1,); + } +} + +func get_min{range_check_ptr}(op1, op2) -> (result: felt) { + let le = is_le(op1, op2); + if (le == 1) { + return (op1,); + } else { + return (op2,); + } +} + +func floor_div{range_check_ptr}(a, b) -> (res: felt) { + let (q, _) = unsigned_div_rem(a, b); + return (q,); +} + +func ceil_div{range_check_ptr}(a, b) -> (res: felt) { + let (q, r) = unsigned_div_rem(a, b); + if (r == 0) { + return (q,); + } else { + return (q + 1,); + } +} + +func update_msize{range_check_ptr}(msize, offset, size) -> (result: felt) { + // Update MSIZE on memory access from 'offset' to 'offset + + // size', according to the rules specified in the yellow paper. + if (size == 0) { + return (msize,); + } + + let (result) = get_max(msize, offset + size); + return (result,); +} + +func round_down_to_multiple{range_check_ptr}(x, div) -> (y: felt) { + let (r) = floor_div(x, div); + return (r * div,); +} + +func round_up_to_multiple{range_check_ptr}(x, div) -> (y: felt) { + let (r) = ceil_div(x, div); + return (r * div,); +} + +func felt_to_uint256{range_check_ptr}(x) -> (x_: Uint256) { + let split = split_felt(x); + return (Uint256(low=split.low, high=split.high),); +} + +func uint256_to_address_felt(x: Uint256) -> (address: felt) { + return (x.low + x.high * 2 ** 128,); +} + +func narrow_safe{range_check_ptr}(x: Uint256) -> (val: felt) { + let (boundHigh, boundLow) = split_felt(-1); + let (inRange) = uint256_le(x, Uint256(boundLow, boundHigh)); + assert inRange = 1; + return (x.low + 2 ** 128 * x.high,); +} diff --git a/cairo1/linux_x64/corelib/src/warplib/maths/xor.cairo b/cairo1/linux_x64/corelib/src/warplib/maths/xor.cairo new file mode 100644 index 000000000..a5dd18280 --- /dev/null +++ b/cairo1/linux_x64/corelib/src/warplib/maths/xor.cairo @@ -0,0 +1,15 @@ +from starkware.cairo.common.bitwise import bitwise_xor +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin +from starkware.cairo.common.uint256 import Uint256, uint256_xor + +func warp_xor{bitwise_ptr: BitwiseBuiltin*}(lhs: felt, rhs: felt) -> (res: felt) { + let (res) = bitwise_xor(lhs, rhs); + return (res,); +} + +func warp_xor256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(lhs: Uint256, rhs: Uint256) -> ( + res: Uint256 +) { + let (res) = uint256_xor(lhs, rhs); + return (res,); +} diff --git a/src/cairoUtilFuncGen/abi/abiDecode.ts b/src/cairoUtilFuncGen/abi/abiDecode.ts index 67aca991f..ff5eb5025 100644 --- a/src/cairoUtilFuncGen/abi/abiDecode.ts +++ b/src/cairoUtilFuncGen/abi/abiDecode.ts @@ -42,7 +42,7 @@ import { DYNAMIC_ARRAYS_UTIL, FELT_TO_UINT256, NARROW_SAFE, - UINT256, + GET_U128, WM_INDEX_DYN, WM_NEW, WM_ALLOC, @@ -317,7 +317,7 @@ export class AbiDecode extends StringIndexedFuncGenWithAuxiliar { if (byteSize === 32) { args.push('0'); - importedFuncs.push(this.requireImport(...UINT256)); + importedFuncs.push(this.requireImport(...GET_U128)); } const decodeType = byteSize === 32 ? 'Uint256' : 'felt'; @@ -435,7 +435,7 @@ export class AbiDecode extends StringIndexedFuncGenWithAuxiliar { ].join('\n'); const importedFuncs = [ - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...WM_INDEX_DYN), this.requireImport(...FELT_TO_UINT256), this.requireImport(...NARROW_SAFE), diff --git a/src/cairoUtilFuncGen/abi/abiEncode.ts b/src/cairoUtilFuncGen/abi/abiEncode.ts index 6a529e331..84087ec9e 100644 --- a/src/cairoUtilFuncGen/abi/abiEncode.ts +++ b/src/cairoUtilFuncGen/abi/abiEncode.ts @@ -18,7 +18,7 @@ import { FELT_ARRAY_TO_WARP_MEMORY_ARRAY, FELT_TO_UINT256, NARROW_SAFE, - UINT256, + GET_U128, WM_DYN_ARRAY_LENGTH, WM_INDEX_DYN, WM_NEW, @@ -102,7 +102,7 @@ export class AbiEncode extends AbiBase { const importedFuncs = [ this.requireImport(...ALLOC), - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...FELT_TO_UINT256), this.requireImport(...WM_NEW), this.requireImport(...FELT_ARRAY_TO_WARP_MEMORY_ARRAY), diff --git a/src/cairoUtilFuncGen/abi/abiEncodePacked.ts b/src/cairoUtilFuncGen/abi/abiEncodePacked.ts index 7279c89d7..2ce122807 100644 --- a/src/cairoUtilFuncGen/abi/abiEncodePacked.ts +++ b/src/cairoUtilFuncGen/abi/abiEncodePacked.ts @@ -29,7 +29,7 @@ import { FELT_TO_UINT256, FIXED_BYTES256_TO_FELT_DYNAMIC_ARRAY, NARROW_SAFE, - UINT256, + GET_U128, WM_DYN_ARRAY_LENGTH, WM_INDEX_DYN, WM_NEW, @@ -88,7 +88,7 @@ export class AbiEncodePacked extends AbiBase { ].join('\n'); const importedFuncs = [ - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...ALLOC), this.requireImport(...FELT_TO_UINT256), this.requireImport(...WM_NEW), diff --git a/src/cairoUtilFuncGen/abi/abiEncodeWithSelector.ts b/src/cairoUtilFuncGen/abi/abiEncodeWithSelector.ts index 3bd702236..4690922f8 100644 --- a/src/cairoUtilFuncGen/abi/abiEncodeWithSelector.ts +++ b/src/cairoUtilFuncGen/abi/abiEncodeWithSelector.ts @@ -9,7 +9,7 @@ import { FELT_ARRAY_TO_WARP_MEMORY_ARRAY, FELT_TO_UINT256, FIXED_BYTES256_TO_FELT_DYNAMIC_ARRAY, - UINT256, + GET_U128, WARP_KECCAK, WM_NEW, } from '../../utils/importPaths'; @@ -91,7 +91,7 @@ export class AbiEncodeWithSelector extends AbiBase { ].join('\n'); const importedFuncs = [ - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...ALLOC), this.requireImport(...FELT_TO_UINT256), this.requireImport(...WM_NEW), diff --git a/src/cairoUtilFuncGen/abi/abiEncodeWithSignature.ts b/src/cairoUtilFuncGen/abi/abiEncodeWithSignature.ts index 018fc15a3..70da2969d 100644 --- a/src/cairoUtilFuncGen/abi/abiEncodeWithSignature.ts +++ b/src/cairoUtilFuncGen/abi/abiEncodeWithSignature.ts @@ -17,7 +17,7 @@ import { BYTE256_AT_INDEX, FELT_ARRAY_TO_WARP_MEMORY_ARRAY, FELT_TO_UINT256, - UINT256, + GET_U128, WARP_KECCAK, WM_NEW, } from '../../utils/importPaths'; @@ -123,7 +123,7 @@ export class AbiEncodeWithSignature extends AbiEncodeWithSelector { ].join('\n'); const importedFuncs = [ - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...ALLOC), this.requireImport(...FELT_TO_UINT256), this.requireImport(...WM_NEW), diff --git a/src/cairoUtilFuncGen/abi/indexEncode.ts b/src/cairoUtilFuncGen/abi/indexEncode.ts index 5374b82f5..24b82e594 100644 --- a/src/cairoUtilFuncGen/abi/indexEncode.ts +++ b/src/cairoUtilFuncGen/abi/indexEncode.ts @@ -20,7 +20,7 @@ import { FELT_ARRAY_TO_WARP_MEMORY_ARRAY, FELT_TO_UINT256, NARROW_SAFE, - UINT256, + GET_U128, WM_DYN_ARRAY_LENGTH, WM_INDEX_DYN, WM_NEW, @@ -95,7 +95,7 @@ export class IndexEncode extends AbiBase { const importedFuncs = [ this.requireImport(...ALLOC), this.requireImport(...BITWISE_BUILTIN), - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...FELT_TO_UINT256), this.requireImport(...WM_NEW), this.requireImport(...FELT_ARRAY_TO_WARP_MEMORY_ARRAY), diff --git a/src/cairoUtilFuncGen/calldata/calldataToMemory.ts b/src/cairoUtilFuncGen/calldata/calldataToMemory.ts index a22df445e..3eee13846 100644 --- a/src/cairoUtilFuncGen/calldata/calldataToMemory.ts +++ b/src/cairoUtilFuncGen/calldata/calldataToMemory.ts @@ -26,7 +26,7 @@ import { safeGetNodeType, } from '../../utils/nodeTypeProcessing'; import { CairoFunctionDefinition } from '../../export'; -import { DICT_WRITE, FELT_TO_UINT256, UINT256, WM_ALLOC, WM_NEW } from '../../utils/importPaths'; +import { DICT_WRITE, FELT_TO_UINT256, GET_U128, WM_ALLOC, WM_NEW } from '../../utils/importPaths'; const IMPLICITS = '{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr : felt, warp_memory : DictAccess*}'; @@ -129,7 +129,7 @@ export class CallDataToMemoryGen extends StringIndexedFuncGen { `}`, ].join('\n'), functionsCalled: [ - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...WM_NEW), this.requireImport(...FELT_TO_UINT256), auxFunc, @@ -181,7 +181,7 @@ export class CallDataToMemoryGen extends StringIndexedFuncGen { ].join('\n'), functionsCalled: [ this.requireImport(...WM_ALLOC), - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...DICT_WRITE), ...funcCalls, ], @@ -240,7 +240,7 @@ export class CallDataToMemoryGen extends StringIndexedFuncGen { ].join('\n'), functionsCalled: [ this.requireImport(...DICT_WRITE), - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...WM_ALLOC), ...funcCalls, ], diff --git a/src/cairoUtilFuncGen/calldata/implicitArrayConversion.ts b/src/cairoUtilFuncGen/calldata/implicitArrayConversion.ts index 82dc0b8db..e272b1b67 100644 --- a/src/cairoUtilFuncGen/calldata/implicitArrayConversion.ts +++ b/src/cairoUtilFuncGen/calldata/implicitArrayConversion.ts @@ -29,7 +29,7 @@ import { BYTES_CONVERSIONS, FELT_TO_UINT256, INT_CONVERSIONS, - UINT256, + GET_U128, } from '../../utils/importPaths'; const IMPLICITS = @@ -233,7 +233,7 @@ export class ImplicitArrayConversion extends StringIndexedFuncGen { return { name: funcName, code: code, - functionsCalled: [this.requireImport(...UINT256), ...requiredFunctions, ...optionalImport], + functionsCalled: [this.requireImport(...GET_U128), ...requiredFunctions, ...optionalImport], }; } diff --git a/src/cairoUtilFuncGen/enumInputCheck.ts b/src/cairoUtilFuncGen/enumInputCheck.ts index b47195e89..cb48bf498 100644 --- a/src/cairoUtilFuncGen/enumInputCheck.ts +++ b/src/cairoUtilFuncGen/enumInputCheck.ts @@ -11,7 +11,7 @@ import { } from 'solc-typed-ast'; import { FunctionStubKind } from '../ast/cairoNodes'; import { createCairoGeneratedFunction, createCallToFunction } from '../utils/functionGeneration'; -import { IS_LE_FELT, NARROW_SAFE, UINT256 } from '../utils/importPaths'; +import { IS_LE_FELT, NARROW_SAFE, GET_U128 } from '../utils/importPaths'; import { safeGetNodeType } from '../utils/nodeTypeProcessing'; import { typeNameFromTypeNode } from '../utils/utils'; import { GeneratedFunctionInfo, StringIndexedFuncGen } from './base'; @@ -65,7 +65,7 @@ export class EnumInputCheck extends StringIndexedFuncGen { const imports = [this.requireImport(...IS_LE_FELT)]; if (input256Bits) { - imports.push(this.requireImport(...NARROW_SAFE), this.requireImport(...UINT256)); + imports.push(this.requireImport(...NARROW_SAFE), this.requireImport(...GET_U128)); } const implicits = '{range_check_ptr : felt}'; diff --git a/src/cairoUtilFuncGen/event.ts b/src/cairoUtilFuncGen/event.ts index 5ae97dc61..53589bf3f 100644 --- a/src/cairoUtilFuncGen/event.ts +++ b/src/cairoUtilFuncGen/event.ts @@ -32,7 +32,7 @@ import { FELT_TO_UINT256, FIXED_BYTES256_TO_FELT_DYNAMIC_ARRAY_SPL, PACK_BYTES_FELT, - UINT256, + GET_U128, WARP_KECCAK, WM_TO_FELT_ARRAY, } from '../utils/importPaths'; @@ -206,7 +206,7 @@ export class EventFunction extends StringIndexedFuncGen { ` let (keys_len: felt) = fixed_bytes256_to_felt_dynamic_array_spl(keys_len, keys, 0, topic256);`, ].join('\n'), [ - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...FELT_TO_UINT256), this.requireImport(...FIXED_BYTES256_TO_FELT_DYNAMIC_ARRAY_SPL), ], @@ -247,7 +247,7 @@ export class EventFunction extends StringIndexedFuncGen { ` let (${arrayName}_len: felt) = fixed_bytes256_to_felt_dynamic_array_spl(${arrayName}_len, ${arrayName}, 0, keccak_hash256);`, ].join('\n'), [ - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...FELT_TO_UINT256), this.requireImport(...WARP_KECCAK), this.requireImport(...FIXED_BYTES256_TO_FELT_DYNAMIC_ARRAY_SPL), diff --git a/src/cairoUtilFuncGen/memory/arrayConcat.ts b/src/cairoUtilFuncGen/memory/arrayConcat.ts index 822296251..3a9a03b33 100644 --- a/src/cairoUtilFuncGen/memory/arrayConcat.ts +++ b/src/cairoUtilFuncGen/memory/arrayConcat.ts @@ -25,7 +25,7 @@ import { DYNAMIC_ARRAYS_UTIL, FELT_TO_UINT256, NARROW_SAFE, - UINT256, + GET_U128, WM_DYN_ARRAY_LENGTH, WM_NEW, } from '../../utils/importPaths'; @@ -116,7 +116,7 @@ export class MemoryArrayConcat extends StringIndexedFuncGen { ` return (res_loc,);`, `}`, ].join('\n'), - functionsCalled: [this.requireImport(...UINT256), this.requireImport(...WM_NEW)], + functionsCalled: [this.requireImport(...GET_U128), this.requireImport(...WM_NEW)], }; } @@ -171,7 +171,7 @@ export class MemoryArrayConcat extends StringIndexedFuncGen { name: funcName, code: code, functionsCalled: [ - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...FELT_TO_UINT256), this.requireImport(...WM_NEW), ...argSizesImports, diff --git a/src/cairoUtilFuncGen/memory/arrayLiteral.ts b/src/cairoUtilFuncGen/memory/arrayLiteral.ts index 98416906b..b8c27cf54 100644 --- a/src/cairoUtilFuncGen/memory/arrayLiteral.ts +++ b/src/cairoUtilFuncGen/memory/arrayLiteral.ts @@ -17,7 +17,7 @@ import { printNode } from '../../utils/astPrinter'; import { CairoType } from '../../utils/cairoTypeSystem'; import { cloneASTNode } from '../../utils/cloning'; import { createCairoGeneratedFunction, createCallToFunction } from '../../utils/functionGeneration'; -import { DICT_WRITE, UINT256, WM_ALLOC, WM_WRITE256 } from '../../utils/importPaths'; +import { DICT_WRITE, GET_U128, WM_ALLOC, WM_WRITE256 } from '../../utils/importPaths'; import { createNumberLiteral } from '../../utils/nodeTemplates'; import { getElementType, @@ -141,7 +141,7 @@ export class MemoryArrayLiteralGen extends StringIndexedFuncGen { functionsCalled: [ this.requireImport(...WM_ALLOC), this.requireImport(...WM_WRITE256), - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...DICT_WRITE), ], }; diff --git a/src/cairoUtilFuncGen/memory/implicitConversion.ts b/src/cairoUtilFuncGen/memory/implicitConversion.ts index 8388cadc8..5a8828220 100644 --- a/src/cairoUtilFuncGen/memory/implicitConversion.ts +++ b/src/cairoUtilFuncGen/memory/implicitConversion.ts @@ -24,7 +24,7 @@ import { BYTES_CONVERSIONS, FELT_TO_UINT256, INT_CONVERSIONS, - UINT256, + GET_U128, UINT256_ADD, WM_ALLOC, WM_INDEX_DYN, @@ -230,7 +230,7 @@ export class MemoryImplicitConversionGen extends StringIndexedFuncGen { name: funcName, code: code, functionsCalled: [ - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...WM_ALLOC), sourceLocationFunc, ...calledFuncs, @@ -310,7 +310,7 @@ export class MemoryImplicitConversionGen extends StringIndexedFuncGen { name: funcName, code: code, functionsCalled: [ - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...UINT256_ADD), this.requireImport(...WM_INDEX_DYN), this.requireImport(...WM_NEW), @@ -386,7 +386,7 @@ export class MemoryImplicitConversionGen extends StringIndexedFuncGen { name: funcName, code: code, functionsCalled: [ - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...UINT256_ADD), this.requireImport(...WM_INDEX_DYN), this.requireImport(...WM_NEW), diff --git a/src/cairoUtilFuncGen/memory/memoryStruct.ts b/src/cairoUtilFuncGen/memory/memoryStruct.ts index 21311ef57..8cb384d31 100644 --- a/src/cairoUtilFuncGen/memory/memoryStruct.ts +++ b/src/cairoUtilFuncGen/memory/memoryStruct.ts @@ -11,7 +11,7 @@ import { import { CairoStruct, CairoType, TypeConversionContext } from '../../utils/cairoTypeSystem'; import { cloneASTNode } from '../../utils/cloning'; import { createCairoGeneratedFunction, createCallToFunction } from '../../utils/functionGeneration'; -import { DICT_ACCESS, DICT_WRITE, UINT256, WM_ALLOC } from '../../utils/importPaths'; +import { DICT_ACCESS, DICT_WRITE, GET_U128, WM_ALLOC } from '../../utils/importPaths'; import { safeGetNodeType, typeNameToSpecializedTypeNode } from '../../utils/nodeTypeProcessing'; import { uint256 } from '../../warplib/utils'; import { add, GeneratedFunctionInfo, StringIndexedFuncGen } from '../base'; @@ -105,7 +105,7 @@ export class MemoryStructGen extends StringIndexedFuncGen { this.requireImport(...WM_ALLOC), this.requireImport(...DICT_WRITE), this.requireImport(...DICT_ACCESS), - this.requireImport(...UINT256), + this.requireImport(...GET_U128), ], }; } diff --git a/src/cairoUtilFuncGen/memory/memoryToCalldata.ts b/src/cairoUtilFuncGen/memory/memoryToCalldata.ts index 66cde60f2..efbf6946e 100644 --- a/src/cairoUtilFuncGen/memory/memoryToCalldata.ts +++ b/src/cairoUtilFuncGen/memory/memoryToCalldata.ts @@ -19,7 +19,7 @@ import { printTypeNode } from '../../utils/astPrinter'; import { CairoDynArray, CairoType, TypeConversionContext } from '../../utils/cairoTypeSystem'; import { NotSupportedYetError } from '../../utils/errors'; import { createCairoGeneratedFunction, createCallToFunction } from '../../utils/functionGeneration'; -import { ALLOC, NARROW_SAFE, WM_READ256, UINT256 } from '../../utils/importPaths'; +import { ALLOC, NARROW_SAFE, WM_READ256, GET_U128 } from '../../utils/importPaths'; import { getElementType, getSize, @@ -227,7 +227,7 @@ export class MemoryToCallDataGen extends StringIndexedFuncGen { `let (mem_read1) = ${auxFunc.name}(mem_read0);`, `assert ptr[0] = mem_read1;`, ]; - funcCalls = [this.requireImport(...UINT256), auxFunc, readFunc]; + funcCalls = [this.requireImport(...GET_U128), auxFunc, readFunc]; } else { code = [`let (mem_read0) = ${readFunc.name}(mem_loc);`, 'assert ptr[0] = mem_read0;']; funcCalls = [readFunc]; @@ -268,7 +268,7 @@ export class MemoryToCallDataGen extends StringIndexedFuncGen { )});`, `let (member${index})= ${memberGetterFunc.name}(read_${index});`, ], - [this.requireImport(...UINT256), memberGetterFunc, readFunc], + [this.requireImport(...GET_U128), memberGetterFunc, readFunc], offset + 1, ]; } diff --git a/src/cairoUtilFuncGen/memory/memoryToStorage.ts b/src/cairoUtilFuncGen/memory/memoryToStorage.ts index 31b50ca8c..a42cb85cb 100644 --- a/src/cairoUtilFuncGen/memory/memoryToStorage.ts +++ b/src/cairoUtilFuncGen/memory/memoryToStorage.ts @@ -23,7 +23,7 @@ import { DICT_READ, WM_DYN_ARRAY_LENGTH, NARROW_SAFE, - UINT256, + GET_U128, UINT256_LT, UINT256_SUB, } from '../../utils/importPaths'; @@ -354,7 +354,7 @@ export class MemoryToStorageGen extends StringIndexedFuncGen { ]; return [ [...code, ...copyCode], - [...funcCalls, this.requireImport(...UINT256), readFunc, auxFunc], + [...funcCalls, this.requireImport(...GET_U128), readFunc, auxFunc], storageOffset + typeFeltWidth, memOffset + 1, ]; diff --git a/src/cairoUtilFuncGen/serialisation.ts b/src/cairoUtilFuncGen/serialisation.ts index 31abff3a5..7c4f93436 100644 --- a/src/cairoUtilFuncGen/serialisation.ts +++ b/src/cairoUtilFuncGen/serialisation.ts @@ -3,6 +3,7 @@ import { CairoStaticArray, CairoStruct, CairoType, + CairoUint256, WarpLocation, } from '../utils/cairoTypeSystem'; import { TranspileFailedError } from '../utils/errors'; @@ -48,18 +49,35 @@ function producePackExpression(type: CairoType): (string | Read)[] { ]; } if (type instanceof CairoStruct) { + if (type.fullStringRepresentation === CairoUint256.fullStringRepresentation) { + return [ + type.name, + '{', + ...[...type.members.entries()] + .flatMap(([memberName, memberType]) => [ + memberName, + ':', + 'u128_from_felt(', + ...producePackExpression(memberType), + ')', + ',', + ]) + .slice(0, -1), + '}', + ]; + } return [ type.name, - '(', + '{', ...[...type.members.entries()] .flatMap(([memberName, memberType]) => [ memberName, - '=', + ':', ...producePackExpression(memberType), ',', ]) .slice(0, -1), - ')', + '}', ]; } diff --git a/src/cairoUtilFuncGen/storage/copyToStorage.ts b/src/cairoUtilFuncGen/storage/copyToStorage.ts index 66802af23..e9e497325 100644 --- a/src/cairoUtilFuncGen/storage/copyToStorage.ts +++ b/src/cairoUtilFuncGen/storage/copyToStorage.ts @@ -25,7 +25,7 @@ import { FELT_TO_UINT256, INT_CONVERSIONS, IS_LE, - UINT256, + GET_U128, UINT256_ADD, UINT256_LT, UINT256_SUB, @@ -326,7 +326,7 @@ export class StorageToStorageGen extends StringIndexedFuncGen { `}`, ].join('\n'), functionsCalled: [ - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...UINT256_SUB), this.requireImport(...UINT256_LT), elementCopyFunc, @@ -414,7 +414,7 @@ export class StorageToStorageGen extends StringIndexedFuncGen { `}`, ].join('\n'), functionsCalled: [ - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...UINT256_ADD), this.requireImport(...UINT256_LT), elementCopyFunc, @@ -472,7 +472,7 @@ export class StorageToStorageGen extends StringIndexedFuncGen { `}`, ].join('\n'), functionsCalled: [ - this.requireImport(...UINT256), + this.requireImport(...GET_U128), toType.signed ? this.requireImport(INT_CONVERSIONS, `warp_int${fromType.nBits}_to_int${toType.nBits}`) : this.requireImport(...FELT_TO_UINT256), @@ -525,7 +525,7 @@ export class StorageToStorageGen extends StringIndexedFuncGen { ].join('\n'), functionsCalled: [ this.requireImport(BYTES_CONVERSIONS, conversionFunc), - this.requireImport(...UINT256), + this.requireImport(...GET_U128), ], }; } diff --git a/src/cairoUtilFuncGen/storage/dynArrayIndexAccess.ts b/src/cairoUtilFuncGen/storage/dynArrayIndexAccess.ts index 4bed695c5..35d4ab450 100644 --- a/src/cairoUtilFuncGen/storage/dynArrayIndexAccess.ts +++ b/src/cairoUtilFuncGen/storage/dynArrayIndexAccess.ts @@ -10,7 +10,7 @@ import { import { AST } from '../../ast/ast'; import { CairoType, TypeConversionContext } from '../../utils/cairoTypeSystem'; import { createCairoGeneratedFunction, createCallToFunction } from '../../utils/functionGeneration'; -import { UINT256, UINT256_LT } from '../../utils/importPaths'; +import { GET_U128, UINT256_LT } from '../../utils/importPaths'; import { createUint256TypeName } from '../../utils/nodeTemplates'; import { isDynamicArray, safeGetNodeType } from '../../utils/nodeTypeProcessing'; import { typeNameFromTypeNode } from '../../utils/utils'; @@ -89,7 +89,7 @@ export class DynArrayIndexAccessGen extends StringIndexedFuncGen { `}`, ].join('\n'), functionsCalled: [ - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...UINT256_LT), arrayDef, arrayLength, diff --git a/src/cairoUtilFuncGen/storage/dynArrayPop.ts b/src/cairoUtilFuncGen/storage/dynArrayPop.ts index c10927d34..63db75a09 100644 --- a/src/cairoUtilFuncGen/storage/dynArrayPop.ts +++ b/src/cairoUtilFuncGen/storage/dynArrayPop.ts @@ -14,7 +14,7 @@ import { AST } from '../../ast/ast'; import { CairoFunctionDefinition } from '../../export'; import { CairoType, TypeConversionContext } from '../../utils/cairoTypeSystem'; import { createCairoGeneratedFunction, createCallToFunction } from '../../utils/functionGeneration'; -import { UINT256, UINT256_EQ, UINT256_SUB } from '../../utils/importPaths'; +import { GET_U128, UINT256_EQ, UINT256_SUB } from '../../utils/importPaths'; import { getElementType, isDynamicArray, @@ -110,7 +110,7 @@ export class DynArrayPopGen extends StringIndexedFuncGen { `}`, ].join('\n'), functionsCalled: [ - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...UINT256_EQ), this.requireImport(...UINT256_SUB), deleteFunc, diff --git a/src/cairoUtilFuncGen/storage/dynArrayPushWithArg.ts b/src/cairoUtilFuncGen/storage/dynArrayPushWithArg.ts index 13db70366..fbfac3b83 100644 --- a/src/cairoUtilFuncGen/storage/dynArrayPushWithArg.ts +++ b/src/cairoUtilFuncGen/storage/dynArrayPushWithArg.ts @@ -29,7 +29,7 @@ import { specializeType, } from '../../utils/nodeTypeProcessing'; import { ImplicitArrayConversion } from '../calldata/implicitArrayConversion'; -import { UINT256, UINT256_ADD } from '../../utils/importPaths'; +import { GET_U128, UINT256_ADD } from '../../utils/importPaths'; export class DynArrayPushWithArgGen extends StringIndexedFuncGen { public constructor( @@ -176,7 +176,7 @@ export class DynArrayPushWithArgGen extends StringIndexedFuncGen { `}`, ].join('\n'), functionsCalled: [ - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...UINT256_ADD), elementWriteDef, dynArray, diff --git a/src/cairoUtilFuncGen/storage/dynArrayPushWithoutArg.ts b/src/cairoUtilFuncGen/storage/dynArrayPushWithoutArg.ts index f18c1935e..a6e8e42b7 100644 --- a/src/cairoUtilFuncGen/storage/dynArrayPushWithoutArg.ts +++ b/src/cairoUtilFuncGen/storage/dynArrayPushWithoutArg.ts @@ -13,7 +13,7 @@ import { AST } from '../../ast/ast'; import { printTypeNode } from '../../export'; import { CairoType, TypeConversionContext } from '../../utils/cairoTypeSystem'; import { createCairoGeneratedFunction, createCallToFunction } from '../../utils/functionGeneration'; -import { UINT256, UINT256_ADD } from '../../utils/importPaths'; +import { GET_U128, UINT256_ADD } from '../../utils/importPaths'; import { getElementType, safeGetNodeType } from '../../utils/nodeTypeProcessing'; import { typeNameFromTypeNode } from '../../utils/utils'; import { GeneratedFunctionInfo, StringIndexedFuncGen } from '../base'; @@ -90,7 +90,7 @@ export class DynArrayPushWithoutArgGen extends StringIndexedFuncGen { `}`, ].join('\n'), functionsCalled: [ - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...UINT256_ADD), dynArray, dynArrayLength, diff --git a/src/cairoUtilFuncGen/storage/mappingIndexAccess.ts b/src/cairoUtilFuncGen/storage/mappingIndexAccess.ts index eb1e46e60..ca4324e7c 100644 --- a/src/cairoUtilFuncGen/storage/mappingIndexAccess.ts +++ b/src/cairoUtilFuncGen/storage/mappingIndexAccess.ts @@ -133,10 +133,10 @@ export class MappingIndexAccessGen extends CairoUtilFuncGenBase { name: funcName, code: endent` fn ${funcName}(name: felt, index: ${indexCairoType}) -> felt { - let existing = ${mappingName}::read(name, index); + let existing = ${mappingName}::read((name, index)); if existing == 0 { let used = WARP_USED_STORAGE::read(); - ${mappingName}::write(name, index, used); + ${mappingName}::write((name, index), used); return used; } return existing; diff --git a/src/cairoUtilFuncGen/storage/storageDelete.ts b/src/cairoUtilFuncGen/storage/storageDelete.ts index b0646efcb..cea98723a 100644 --- a/src/cairoUtilFuncGen/storage/storageDelete.ts +++ b/src/cairoUtilFuncGen/storage/storageDelete.ts @@ -18,7 +18,7 @@ import { CairoGeneratedFunctionDefinition } from '../../ast/cairoNodes'; import { CairoFunctionDefinition } from '../../export'; import { CairoType, TypeConversionContext } from '../../utils/cairoTypeSystem'; import { createCairoGeneratedFunction, createCallToFunction } from '../../utils/functionGeneration'; -import { UINT256, UINT256_ADD, UINT256_EQ, UINT256_SUB } from '../../utils/importPaths'; +import { GET_U128, UINT256_ADD, UINT256_EQ, UINT256_SUB } from '../../utils/importPaths'; import { getElementType, isDynamicArray, safeGetNodeType } from '../../utils/nodeTypeProcessing'; import { typeNameFromTypeNode, mapRange, narrowBigIntSafe } from '../../utils/utils'; import { uint256 } from '../../warplib/utils'; @@ -176,7 +176,7 @@ export class StorageDeleteGen extends StringIndexedFuncGen { const importedFuncs = [ this.requireImport(...UINT256_EQ), this.requireImport(...UINT256_ADD), - this.requireImport(...UINT256), + this.requireImport(...GET_U128), ]; return { name: funcName, @@ -251,7 +251,7 @@ export class StorageDeleteGen extends StringIndexedFuncGen { const importedFuncs = [ this.requireImport(...UINT256_EQ), this.requireImport(...UINT256_SUB), - this.requireImport(...UINT256), + this.requireImport(...GET_U128), ]; return { diff --git a/src/cairoUtilFuncGen/storage/storageToCalldata.ts b/src/cairoUtilFuncGen/storage/storageToCalldata.ts index 0fd7ce422..a5d9a17b8 100644 --- a/src/cairoUtilFuncGen/storage/storageToCalldata.ts +++ b/src/cairoUtilFuncGen/storage/storageToCalldata.ts @@ -17,7 +17,7 @@ import { printTypeNode } from '../../utils/astPrinter'; import { CairoDynArray, CairoType, TypeConversionContext } from '../../utils/cairoTypeSystem'; import { NotSupportedYetError } from '../../utils/errors'; import { createCairoGeneratedFunction, createCallToFunction } from '../../utils/functionGeneration'; -import { ALLOC, UINT256, WARP_UINT256 } from '../../utils/importPaths'; +import { ALLOC, GET_U128, WARP_UINT256 } from '../../utils/importPaths'; import { getElementType, safeGetNodeType } from '../../utils/nodeTypeProcessing'; import { mapRange, narrowBigIntSafe, typeNameFromTypeNode } from '../../utils/utils'; import { add, delegateBasedOnType, GeneratedFunctionInfo, StringIndexedFuncGen } from '../base'; @@ -193,7 +193,7 @@ export class StorageToCalldataGen extends StringIndexedFuncGen { const importedFuncs = [ this.requireImport(...WARP_UINT256), - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...ALLOC), ]; diff --git a/src/cairoUtilFuncGen/storage/storageToMemory.ts b/src/cairoUtilFuncGen/storage/storageToMemory.ts index 9a7193651..2725a4216 100644 --- a/src/cairoUtilFuncGen/storage/storageToMemory.ts +++ b/src/cairoUtilFuncGen/storage/storageToMemory.ts @@ -22,7 +22,7 @@ import { NotSupportedYetError } from '../../utils/errors'; import { createCairoGeneratedFunction, createCallToFunction } from '../../utils/functionGeneration'; import { DICT_WRITE, - UINT256, + GET_U128, UINT256_SUB, WM_ALLOC, WM_INDEX_DYN, @@ -233,7 +233,7 @@ export class StorageToMemoryGen extends StringIndexedFuncGen { this.requireImport(...DICT_WRITE), this.requireImport(...WM_ALLOC), this.requireImport(...UINT256_SUB), - this.requireImport(...UINT256), + this.requireImport(...GET_U128), ...copyCalls, ], }; @@ -287,7 +287,7 @@ export class StorageToMemoryGen extends StringIndexedFuncGen { functionsCalled: [ this.requireImport(...DICT_WRITE), this.requireImport(...UINT256_SUB), - this.requireImport(...UINT256), + this.requireImport(...GET_U128), this.requireImport(...WM_NEW), this.requireImport(...WM_INDEX_DYN), ...copyCalls, diff --git a/src/cairoUtilFuncGen/storage/storageWrite.ts b/src/cairoUtilFuncGen/storage/storageWrite.ts index 24b67e6ff..0a3ad6f09 100644 --- a/src/cairoUtilFuncGen/storage/storageWrite.ts +++ b/src/cairoUtilFuncGen/storage/storageWrite.ts @@ -1,8 +1,9 @@ import endent from 'endent'; import { Expression, FunctionCall, TypeNode, DataLocation, PointerType } from 'solc-typed-ast'; -import { CairoType, TypeConversionContext } from '../../utils/cairoTypeSystem'; +import { CairoType, CairoUint256, TypeConversionContext } from '../../utils/cairoTypeSystem'; import { cloneASTNode } from '../../utils/cloning'; import { createCairoGeneratedFunction, createCallToFunction } from '../../utils/functionGeneration'; +import { U128_TO_FELT } from '../../utils/importPaths'; import { safeGetNodeType } from '../../utils/nodeTypeProcessing'; import { typeNameFromTypeNode } from '../../utils/utils'; import { add, GeneratedFunctionInfo, StringIndexedFuncGen } from '../base'; @@ -56,7 +57,12 @@ export class StorageWriteGen extends StringIndexedFuncGen { const cairoTypeString = cairoTypeToWrite.toString(); const writeCode = cairoTypeToWrite .serialiseMembers('value') - .map((name, index) => ` ${write(add('loc', index), name)}`) + .map((name, index) => { + if (cairoTypeToWrite.fullStringRepresentation === CairoUint256.fullStringRepresentation) { + name = `u128_to_felt(${name})`; + } + return ` ${write(add('loc', index), name)}`; + }) .join('\n'); const funcName = `WS_WRITE${this.generatedFunctionsDef.size}`; @@ -68,7 +74,7 @@ export class StorageWriteGen extends StringIndexedFuncGen { return value; } `, - functionsCalled: [], + functionsCalled: [this.requireImport(...U128_TO_FELT)], }; return funcInfo; } diff --git a/src/cairoWriter/writers/cairoContractWriter.ts b/src/cairoWriter/writers/cairoContractWriter.ts index b3d07e205..2e9cce24e 100644 --- a/src/cairoWriter/writers/cairoContractWriter.ts +++ b/src/cairoWriter/writers/cairoContractWriter.ts @@ -25,10 +25,10 @@ export class CairoContractWriter extends CairoASTNodeWriter { ]; const dynamicVariables = [...node.dynamicStorageAllocations.entries()].map( - ([decl, loc]) => `const ${decl.name} = ${loc};`, + ([decl, loc]) => `const ${decl.name}: felt = ${loc};`, ); const staticVariables = [...node.staticStorageAllocations.entries()].map( - ([decl, loc]) => `const ${decl.name} = ${loc};`, + ([decl, loc]) => `const ${decl.name}: felt = ${loc};`, ); const variables = [ `// Dynamic variables - Arrays and Maps`, diff --git a/src/cairoWriter/writers/cairoFunctionDefinitionWriter.ts b/src/cairoWriter/writers/cairoFunctionDefinitionWriter.ts index 08b3e0645..d421e9665 100644 --- a/src/cairoWriter/writers/cairoFunctionDefinitionWriter.ts +++ b/src/cairoWriter/writers/cairoFunctionDefinitionWriter.ts @@ -155,8 +155,8 @@ export class CairoFunctionDefinitionWriter extends CairoASTNodeWriter { return null; } return [ - contract.usedStorage === 0 ? '' : `WARP_USED_STORAGE.write(${contract.usedStorage});`, - contract.usedIds === 0 ? '' : `WARP_NAMEGEN.write(${contract.usedIds});`, + contract.usedStorage === 0 ? '' : `WARP_USED_STORAGE::write(${contract.usedStorage});`, + contract.usedIds === 0 ? '' : `WARP_NAMEGEN::write(${contract.usedIds});`, ].join(`\n`); } return null; diff --git a/src/passes/annotateImplicits.ts b/src/passes/annotateImplicits.ts index cfce32be6..10cf4b6bf 100644 --- a/src/passes/annotateImplicits.ts +++ b/src/passes/annotateImplicits.ts @@ -12,7 +12,7 @@ import { ASTMapper } from '../ast/mapper'; import { ASTVisitor } from '../ast/visitor'; import { printNode } from '../utils/astPrinter'; import { Implicits, registerImportsForImplicit } from '../utils/implicits'; -import { isExternallyVisible, union } from '../utils/utils'; +import { union } from '../utils/utils'; import { getDocString, isCairoStub } from './cairoStubProcessor'; import { EMIT_PREFIX } from '../export'; import { parseImplicits } from '../utils/cairoParsing'; @@ -97,15 +97,6 @@ class ImplicitCollector extends ASTVisitor> { extractImplicitFromStubs(node, result); return node === this.root ? result : union(result, this.commonVisit(node, ast)); } - if (node.implemented && isExternallyVisible(node)) { - result.add('range_check_ptr'); - result.add('syscall_ptr'); - } - if (node.isConstructor) { - result.add('syscall_ptr'); - result.add('pedersen_ptr'); - result.add('range_check_ptr'); - } if (node === this.root) return result; return union(result, this.commonVisit(node, ast)); diff --git a/src/passes/builtinHandler/msgSender.ts b/src/passes/builtinHandler/msgSender.ts index d872d4eed..d9fd6af70 100644 --- a/src/passes/builtinHandler/msgSender.ts +++ b/src/passes/builtinHandler/msgSender.ts @@ -1,8 +1,15 @@ -import { MemberAccess, Identifier, ExternalReferenceType } from 'solc-typed-ast'; +import { + MemberAccess, + Identifier, + ExternalReferenceType, + FunctionCall, + FunctionCallKind, + ElementaryTypeName, +} from 'solc-typed-ast'; import { AST } from '../../ast/ast'; import { ASTMapper } from '../../ast/mapper'; import { createCallToFunction } from '../../utils/functionGeneration'; -import { GET_CALLER_ADDRESS } from '../../utils/importPaths'; +import { GET_CALLER_ADDRESS, ADDRESS_INTO_FELT } from '../../utils/importPaths'; import { createAddressTypeName } from '../../utils/nodeTemplates'; export class MsgSender extends ASTMapper { @@ -23,7 +30,23 @@ export class MsgSender extends ASTMapper { [], ast, ); - ast.replaceNode(node, replacementCall); + + const IntoTrait = ast.registerImport( + node, + ...ADDRESS_INTO_FELT, + [], + [['uint256', new ElementaryTypeName(ast.reserveId(), '', 'uint256', 'uint256')]], + ); + const asFelt = new FunctionCall( + ast.reserveId(), + '', + 'uint256', + FunctionCallKind.FunctionCall, + new MemberAccess(ast.reserveId(), '', 'uint256', replacementCall, 'into', IntoTrait.id), + [], + ); + + ast.replaceNode(node, asFelt); } // Fine to recurse because there is a check that the member access is a Builtin. Therefor a.msg.sender should // not be picked up. diff --git a/src/passes/cairoUtilImporter.ts b/src/passes/cairoUtilImporter.ts index 6b42d6d1e..acb96fd58 100644 --- a/src/passes/cairoUtilImporter.ts +++ b/src/passes/cairoUtilImporter.ts @@ -2,6 +2,7 @@ import { ElementaryTypeName, IntType, Literal, + MemberAccess, SourceUnit, StructDefinition, UserDefinedType, @@ -17,8 +18,9 @@ import { DEFAULT_DICT_NEW, DICT_WRITE, FINALIZE_KECCAK, + INTO, U256_FROM_FELTS, - UINT256, + GET_U128, } from '../utils/importPaths'; import { safeGetNodeType } from '../utils/nodeTypeProcessing'; import { getContainingSourceUnit, isExternallyVisible, primitiveTypeToCairo } from '../utils/utils'; @@ -41,7 +43,7 @@ export class CairoUtilImporter extends ASTMapper { visitElementaryTypeName(node: ElementaryTypeName, ast: AST): void { if (primitiveTypeToCairo(node.name) === 'Uint256') { - createImport(...UINT256, this.dummySourceUnit ?? node, ast); + createImport(...GET_U128, this.dummySourceUnit ?? node, ast); } } @@ -55,7 +57,7 @@ export class CairoUtilImporter extends ASTMapper { visitVariableDeclaration(node: VariableDeclaration, ast: AST): void { const type = safeGetNodeType(node, ast.inference); if (type instanceof IntType && type.nBits > 251) { - createImport(...UINT256, this.dummySourceUnit ?? node, ast); + createImport(...GET_U128, this.dummySourceUnit ?? node, ast); } // Patch to struct inlining @@ -86,4 +88,10 @@ export class CairoUtilImporter extends ASTMapper { this.commonVisit(node, ast); } + + visitMemberAccess(node: MemberAccess, ast: AST): void { + if (node.memberName === 'into') { + createImport(...INTO, node, ast); + } + } } diff --git a/src/utils/cairoTypeSystem.ts b/src/utils/cairoTypeSystem.ts index 0803c725a..08a41258e 100644 --- a/src/utils/cairoTypeSystem.ts +++ b/src/utils/cairoTypeSystem.ts @@ -278,7 +278,7 @@ export class WarpLocation extends CairoFelt { export class MemoryLocation extends CairoFelt {} export const CairoUint256 = new CairoStruct( - 'Uint256', + 'u256', new Map([ ['low', new CairoFelt()], ['high', new CairoFelt()], diff --git a/src/utils/implicits.ts b/src/utils/implicits.ts index 90e93c2a2..0b31af1ef 100644 --- a/src/utils/implicits.ts +++ b/src/utils/implicits.ts @@ -1,6 +1,6 @@ import { ASTNode } from 'solc-typed-ast'; import { AST } from '../ast/ast'; -import { BITWISE_BUILTIN, DICT_ACCESS, HASH_BUILTIN } from './importPaths'; +import { BITWISE_BUILTIN, DICT_ACCESS } from './importPaths'; export type Implicits = | 'bitwise_ptr' @@ -41,9 +41,6 @@ export function registerImportsForImplicit(ast: AST, node: ASTNode, implicit: Im case 'bitwise_ptr': ast.registerImport(node, ...BITWISE_BUILTIN, [], []); break; - case 'pedersen_ptr': - ast.registerImport(node, ...HASH_BUILTIN, [], []); - break; case 'warp_memory': ast.registerImport(node, ...DICT_ACCESS, [], []); break; diff --git a/src/utils/importFuncGenerator.ts b/src/utils/importFuncGenerator.ts index 57f12ec7c..2a3cbcd49 100644 --- a/src/utils/importFuncGenerator.ts +++ b/src/utils/importFuncGenerator.ts @@ -23,18 +23,20 @@ import { FINALIZE_KECCAK, GET_CALLER_ADDRESS, GET_CONTRACT_ADDRESS, - HASH_BUILTIN, + ADDRESS_INTO_FELT, IS_LE, IS_LE_FELT, SPLIT_FELT, + U128_TO_FELT, U256_FROM_FELTS, - UINT256, + GET_U128, UINT256_ADD, UINT256_EQ, UINT256_LE, UINT256_LT, UINT256_MUL, UINT256_SUB, + INTO, } from './importPaths'; export function createImport( @@ -88,8 +90,6 @@ export function createImport( return createFuncImport(); case encodePath(BITWISE_BUILTIN): return createStructImport(); - case encodePath(HASH_BUILTIN): - return createStructImport(); case encodePath(FINALIZE_KECCAK): return createFuncImport('range_check_ptr', 'bitwise_ptr'); case encodePath(DEFAULT_DICT_NEW): @@ -101,7 +101,7 @@ export function createImport( return createFuncImport('dict_ptr'); case encodePath(DICT_ACCESS): return createStructImport(); - case encodePath(UINT256): + case encodePath(GET_U128): return createStructImport(); case encodePath(SPLIT_FELT): case encodePath(IS_LE): @@ -119,6 +119,9 @@ export function createImport( case encodePath(GET_CONTRACT_ADDRESS): return createFuncImport('syscall_ptr'); // Import libraries from Cairo1 + case encodePath(INTO): + case encodePath(ADDRESS_INTO_FELT): + case encodePath(U128_TO_FELT): case encodePath(U256_FROM_FELTS): return createFuncImport(); default: diff --git a/src/utils/importPaths.ts b/src/utils/importPaths.ts index bfcba3f72..21afcbf95 100644 --- a/src/utils/importPaths.ts +++ b/src/utils/importPaths.ts @@ -23,14 +23,9 @@ export const FINALIZE_KECCAK: [string[], string] = [ [...CAIRO_COMMON_PATH, 'cairo_keccak', 'keccak'], 'finalize_keccak', ]; -export const HASH_BUILTIN: [string[], string] = [ - [...CAIRO_COMMON_PATH, 'cairo_builtins'], - 'HashBuiltin', -]; export const IS_LE: [string[], string] = [[...CAIRO_COMMON_PATH, 'math_cmp'], 'is_le']; export const IS_LE_FELT: [string[], string] = [[...CAIRO_COMMON_PATH, 'math_cmp'], 'is_le_felt']; export const SPLIT_FELT: [string[], string] = [[...CAIRO_COMMON_PATH, 'math'], 'split_felt']; -export const UINT256: [string[], string] = [[...CAIRO_COMMON_PATH, 'uint256'], 'Uint256']; export const UINT256_ADD: [string[], string] = [[...CAIRO_COMMON_PATH, 'uint256'], 'uint256_add']; export const UINT256_EQ: [string[], string] = [[...CAIRO_COMMON_PATH, 'uint256'], 'uint256_eq']; export const UINT256_LE: [string[], string] = [[...CAIRO_COMMON_PATH, 'uint256'], 'uint256_le']; @@ -44,10 +39,6 @@ const STARKWARE_SYSCALL_PATH = ['starkware', 'starknet', 'common', 'syscalls']; export const DEPLOY: [string[], string] = [[...STARKWARE_SYSCALL_PATH], 'deploy']; export const EMIT_EVENT: [string[], string] = [[...STARKWARE_SYSCALL_PATH], 'emit_event']; -export const GET_CALLER_ADDRESS: [string[], string] = [ - [...STARKWARE_SYSCALL_PATH], - 'get_caller_address', -]; export const GET_CONTRACT_ADDRESS: [string[], string] = [ [...STARKWARE_SYSCALL_PATH], 'get_contract_address', @@ -107,3 +98,9 @@ export const WM_WRITE_FELT: [string[], string] = [[...WARPLIB_MEMORY], 'wm_write export const ARRAY_TRAIT: [string[], string] = [['array'], 'ArrayTrait']; export const U256_FROM_FELTS: [string[], string] = [['warplib', 'integer'], 'u256_from_felts']; +export const GET_U128: [string[], string] = [['integer'], 'u128_from_felt']; +export const U128_TO_FELT: [string[], string] = [['integer'], 'u128_to_felt']; + +export const GET_CALLER_ADDRESS: [string[], string] = [['starknet'], 'get_caller_address']; +export const ADDRESS_INTO_FELT: [string[], string] = [['starknet'], 'ContractAddressIntoFelt']; +export const INTO: [string[], string] = [['traits'], 'Into']; diff --git a/src/warplib/implementations/external_input_checks/externalInputChecksInts.ts b/src/warplib/implementations/external_input_checks/externalInputChecksInts.ts index 66c7f4c61..5d8e97bca 100644 --- a/src/warplib/implementations/external_input_checks/externalInputChecksInts.ts +++ b/src/warplib/implementations/external_input_checks/externalInputChecksInts.ts @@ -2,6 +2,7 @@ import { forAllWidths, mask, WarplibFunctionInfo } from '../../utils'; const INDENT = ' '.repeat(4); +// TODO: Check if cairo 1.0 validates outputs itself. Is it needed anymore? export function external_input_check_ints(): WarplibFunctionInfo { return { fileName: 'external_input_check_ints', @@ -9,12 +10,12 @@ export function external_input_check_ints(): WarplibFunctionInfo { functions: forAllWidths((int_width) => { // These functions will not be needed when we transition to map solidity uintN to cairo uN if (int_width === 256) { - return ''; + return 'fn warp_external_input_check_int256(x : u256){}\n'; } else { return [ `fn warp_external_input_check_int${int_width}(x : felt){`, `${INDENT}let max: felt = ${mask(int_width)};`, - `${INDENT}assert( x <= max, "Error: value out-of-bounds.");`, + `${INDENT}assert(x <= max, 'Error: value out-of-bounds.');`, `}\n`, ].join('\n'); } diff --git a/src/warplib/implementations/maths/add.ts b/src/warplib/implementations/maths/add.ts index 429fde246..a5a78904f 100644 --- a/src/warplib/implementations/maths/add.ts +++ b/src/warplib/implementations/maths/add.ts @@ -13,10 +13,12 @@ export function add(): WarplibFunctionInfo { const fileName = 'add'; const functions = forAllWidths((width) => { if (width === 256) { - return ''; + return [`fn warp_add256(lhs: u256, rhs: u256) -> u256{`, ` return lhs + rhs;`, `}`].join( + '\n', + ); } else { return [ - `fn warp_add${width}(lhs : felt, rhs : felt) -> felt{`, + `fn warp_add${width}(lhs: felt, rhs: felt) -> felt{`, ` let res = lhs + rhs;`, ` let max: felt = ${mask(width)};`, ` assert (res <= max, 'Value out of bounds');`, diff --git a/src/warplib/implementations/maths/sub.ts b/src/warplib/implementations/maths/sub.ts index 0dffa91e1..30e25f27b 100644 --- a/src/warplib/implementations/maths/sub.ts +++ b/src/warplib/implementations/maths/sub.ts @@ -16,12 +16,12 @@ import { export function sub_unsafe(): WarplibFunctionInfo { return { fileName: 'sub_unsafe', - imports: ['use integer::u256_overflow_sub'], + imports: ['use integer::u256_overflow_sub;'], functions: forAllWidths((width) => { if (width === 256) { return [ `fn warp_sub_unsafe256(lhs : u256, rhs : u256) -> u256 {`, - ` let (value, _) u256_overflow_sub(lhs, rhs);`, + ` let (value, _) = u256_overflow_sub(lhs, rhs);`, ` return value;`, `}`, ].join('\n'); diff --git a/warplib/maths/external_input_check_address.cairo b/warplib/maths/external_input_check_address.cairo index 94787deb8..6d680747c 100644 --- a/warplib/maths/external_input_check_address.cairo +++ b/warplib/maths/external_input_check_address.cairo @@ -3,5 +3,5 @@ fn warp_external_input_check_address(x: felt) { // The StarkNet address upper bound is 2**251 - 256, in max is stored its hex representation let max: felt = 0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00; - assert( x <= max, "StarkNet address value out-of-bounds"); + assert( x <= max, 'Starknet address out-of-bounds'); } diff --git a/warplib/maths/ge.cairo b/warplib/maths/ge.cairo index fb373ecfa..123e256d1 100644 --- a/warplib/maths/ge.cairo +++ b/warplib/maths/ge.cairo @@ -1,18 +1,8 @@ -fn warp_ge(lhs: felt, rhs: felt) -> felt { - if lhs >= rhs { - return 1; - } - else { - return 0; - } +fn warp_ge(lhs: felt, rhs: felt) -> bool { + return lhs >= rhs; } -fn warp_ge256(op1: u256, op2: u256) -> felt { - if op1 >= op2 { - return 1; - } - else { - return 0; - } +fn warp_ge256(op1: u256, op2: u256) -> bool { + return op1 >= op2; }