From 9aa1998c03a53e6a011c756ec5834457aed0c554 Mon Sep 17 00:00:00 2001 From: AlejandroLabourdette Date: Fri, 3 Mar 2023 10:19:15 -0500 Subject: [PATCH 01/26] update assert writer --- src/cairoWriter/writers/cairoAssertWriter.ts | 15 +++------------ 1 file changed, 3 insertions(+), 12 deletions(-) diff --git a/src/cairoWriter/writers/cairoAssertWriter.ts b/src/cairoWriter/writers/cairoAssertWriter.ts index 61f845964..6bd4a4922 100644 --- a/src/cairoWriter/writers/cairoAssertWriter.ts +++ b/src/cairoWriter/writers/cairoAssertWriter.ts @@ -1,20 +1,11 @@ import { ASTWriter, SrcDesc } from 'solc-typed-ast'; import { CairoAssert } from '../../ast/cairoNodes'; import { CairoASTNodeWriter } from '../base'; -import { INDENT } from '../utils'; export class CairoAssertWriter extends CairoASTNodeWriter { writeInner(node: CairoAssert, writer: ASTWriter): SrcDesc { - const assertExpr = `assert ${writer.write(node.vExpression)} = 1;`; - - if (node.assertMessage === null) { - return [assertExpr]; - } else { - return [ - [`with_attr error_message("${node.assertMessage}"){`, `${INDENT}${assertExpr}`, `}`].join( - '\n', - ), - ]; - } + const expression = writer.write(node.vExpression); + const message = node.assertMessage ?? 'Assertion error'; + return [`assert( ${expression}, "${message}" );`]; } } From 7470dd4096e2c53e3834dc31fc49607b11f0fc55 Mon Sep 17 00:00:00 2001 From: AlejandroLabourdette Date: Fri, 3 Mar 2023 10:20:00 -0500 Subject: [PATCH 02/26] update assignment writer --- src/cairoWriter/writers/assignmentWriter.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cairoWriter/writers/assignmentWriter.ts b/src/cairoWriter/writers/assignmentWriter.ts index 4eb0af228..c33d5b39e 100644 --- a/src/cairoWriter/writers/assignmentWriter.ts +++ b/src/cairoWriter/writers/assignmentWriter.ts @@ -19,7 +19,7 @@ export class AssignmentWriter extends CairoASTNodeWriter { ) && !(lhs instanceof TupleExpression) ) { - return [`let (${nodes[0]}) ${node.operator} ${nodes[1]};`]; + return [`let ${nodes[0]} ${node.operator} ${nodes[1]};`]; } return [`let ${nodes[0]} ${node.operator} ${nodes[1]};`]; } From 522aaec94eb6f073f108dde042b7f4d251c18c51 Mon Sep 17 00:00:00 2001 From: AlejandroLabourdette Date: Fri, 3 Mar 2023 10:21:04 -0500 Subject: [PATCH 03/26] update variable declaration statement writer --- .../variableDeclarationStatementWriter.ts | 18 +----------------- 1 file changed, 1 insertion(+), 17 deletions(-) diff --git a/src/cairoWriter/writers/variableDeclarationStatementWriter.ts b/src/cairoWriter/writers/variableDeclarationStatementWriter.ts index ede03b3f6..596f6f69d 100644 --- a/src/cairoWriter/writers/variableDeclarationStatementWriter.ts +++ b/src/cairoWriter/writers/variableDeclarationStatementWriter.ts @@ -10,7 +10,6 @@ import { VariableDeclaration, VariableDeclarationStatement, } from 'solc-typed-ast'; -import { CairoFunctionDefinition, FunctionStubKind } from '../../ast/cairoNodes'; import { TranspileFailedError } from '../../utils/errors'; import { isDynamicArray, safeGetNodeType } from '../../utils/nodeTypeProcessing'; import { isExternalCall } from '../../utils/utils'; @@ -68,22 +67,7 @@ export class VariableDeclarationStatementWriter extends CairoASTNodeWriter { return [writer.write(getDeclarationForId(id))]; } }); - if ( - node.vInitialValue instanceof FunctionCall && - node.vInitialValue.vReferencedDeclaration instanceof CairoFunctionDefinition && - node.vInitialValue.vReferencedDeclaration.functionStubKind === FunctionStubKind.StructDefStub - ) { - // This local statement is needed since Cairo is not supporting member access of structs with let. - // The type hint also needs to be placed there since Cairo's default type hint is a felt. - return [ - [ - documentation, - `local ${declarations.join(', ')} : ${ - node.vInitialValue.vReferencedDeclaration.name - } = ${writer.write(node.vInitialValue)};`, - ].join('\n'), - ]; - } else if (declarations.length > 1 || node.vInitialValue instanceof FunctionCall) { + if (declarations.length > 1) { return [ [ documentation, From cdcad1cff69f1c16a981a86b6617ec9115210f81 Mon Sep 17 00:00:00 2001 From: AlejandroLabourdette Date: Fri, 3 Mar 2023 10:22:13 -0500 Subject: [PATCH 04/26] update return writer --- src/cairoWriter/writers/returnWriter.ts | 20 ++------------------ 1 file changed, 2 insertions(+), 18 deletions(-) diff --git a/src/cairoWriter/writers/returnWriter.ts b/src/cairoWriter/writers/returnWriter.ts index 211404bfa..a3830a32d 100644 --- a/src/cairoWriter/writers/returnWriter.ts +++ b/src/cairoWriter/writers/returnWriter.ts @@ -1,11 +1,4 @@ -import { - ASTWriter, - FunctionCall, - FunctionCallKind, - Return, - SrcDesc, - TupleExpression, -} from 'solc-typed-ast'; +import { ASTWriter, Return, SrcDesc } from 'solc-typed-ast'; import { CairoFunctionDefinition } from '../../ast/cairoNodes/cairoFunctionDefinition'; import { Implicits } from '../../utils/implicits'; import { isExternallyVisible } from '../../utils/utils'; @@ -17,17 +10,8 @@ const WARP_MEMORY = 'warp_memory'; export class ReturnWriter extends CairoASTNodeWriter { writeInner(node: Return, writer: ASTWriter): SrcDesc { - let returns = '()'; const documentation = getDocumentation(node.documentation, writer); - if (node.vExpression) { - const expWriten = writer.write(node.vExpression); - returns = - node.vExpression instanceof TupleExpression || - (node.vExpression instanceof FunctionCall && - node.vExpression.kind !== FunctionCallKind.StructConstructorCall) - ? expWriten - : `(${expWriten},)`; - } + const returns = node.vExpression ? writer.write(node.vExpression) : '()'; const finalizeWarpMemory = this.usesImplicit(WARP_MEMORY, node) ? 'default_dict_finalize(warp_memory_start, warp_memory, 0);\n' From 3765d069190d7a53b638b5c5d3f197b0f3d6f0fc Mon Sep 17 00:00:00 2001 From: AlejandroLabourdette Date: Fri, 3 Mar 2023 10:23:25 -0500 Subject: [PATCH 05/26] support member access for values and namespaces --- src/cairoWriter/writers/memberAccessWriter.ts | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/cairoWriter/writers/memberAccessWriter.ts b/src/cairoWriter/writers/memberAccessWriter.ts index fe9eeb940..8588eadee 100644 --- a/src/cairoWriter/writers/memberAccessWriter.ts +++ b/src/cairoWriter/writers/memberAccessWriter.ts @@ -1,8 +1,12 @@ -import { ASTWriter, MemberAccess, SrcDesc } from 'solc-typed-ast'; +import { ASTWriter, MemberAccess, SrcDesc, TypeNameType } from 'solc-typed-ast'; import { CairoASTNodeWriter } from '../base'; export class MemberAccessWriter extends CairoASTNodeWriter { writeInner(node: MemberAccess, writer: ASTWriter): SrcDesc { - return [`${writer.write(node.vExpression)}.${node.memberName}`]; + if (this.ast.inference.typeOf(node.vExpression) instanceof TypeNameType) { + return [`${writer.write(node.vExpression)}::${node.memberName}`]; + } else { + return [`${writer.write(node.vExpression)}.${node.memberName}`]; + } } } From 89b466b03a83a434db08c988cce57c0d20cddfbc Mon Sep 17 00:00:00 2001 From: AlejandroLabourdette Date: Fri, 3 Mar 2023 10:24:20 -0500 Subject: [PATCH 06/26] remove Uint256 warp structure from literal writer --- src/cairoWriter/writers/literalWriter.ts | 25 ++---------------------- 1 file changed, 2 insertions(+), 23 deletions(-) diff --git a/src/cairoWriter/writers/literalWriter.ts b/src/cairoWriter/writers/literalWriter.ts index ec9c508ed..c12d5a69c 100644 --- a/src/cairoWriter/writers/literalWriter.ts +++ b/src/cairoWriter/writers/literalWriter.ts @@ -1,22 +1,11 @@ import { ASTWriter, Literal, LiteralKind, SrcDesc } from 'solc-typed-ast'; -import { TranspileFailedError } from '../../utils/errors'; -import { divmod, primitiveTypeToCairo } from '../../utils/utils'; import { CairoASTNodeWriter } from '../base'; export class LiteralWriter extends CairoASTNodeWriter { writeInner(node: Literal, _: ASTWriter): SrcDesc { switch (node.kind) { case LiteralKind.Number: - switch (primitiveTypeToCairo(node.typeString)) { - case 'Uint256': { - const [high, low] = divmod(BigInt(node.value), BigInt(Math.pow(2, 128))); - return [`Uint256(low=${low}, high=${high})`]; - } - case 'felt': - return [node.value]; - default: - throw new TranspileFailedError('Attempted to write unexpected cairo type'); - } + return [node.value]; case LiteralKind.Bool: return [node.value === 'true' ? '1' : '0']; case LiteralKind.String: @@ -31,17 +20,7 @@ export class LiteralWriter extends CairoASTNodeWriter { return [`0x${node.hexValue}`]; } case LiteralKind.HexString: - switch (primitiveTypeToCairo(node.typeString)) { - case 'Uint256': { - return [ - `Uint256(low=0x${node.hexValue.slice(32, 64)}, high=0x${node.hexValue.slice(0, 32)})`, - ]; - } - case 'felt': - return [`0x${node.hexValue}`]; - default: - throw new TranspileFailedError('Attempted to write unexpected cairo type'); - } + return [`0x${node.hexValue}`]; } } } From cc305564eabd081d808ce766ab4f1312d0ac942f Mon Sep 17 00:00:00 2001 From: AlejandroLabourdette Date: Fri, 3 Mar 2023 10:26:00 -0500 Subject: [PATCH 07/26] use expression as condition in if statement writer --- src/cairoWriter/writers/ifStatementWriter.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/cairoWriter/writers/ifStatementWriter.ts b/src/cairoWriter/writers/ifStatementWriter.ts index e4af2f062..2435a6914 100644 --- a/src/cairoWriter/writers/ifStatementWriter.ts +++ b/src/cairoWriter/writers/ifStatementWriter.ts @@ -9,9 +9,9 @@ export class IfStatementWriter extends CairoASTNodeWriter { return [ [ documentation, - `if (${writer.write(node.vCondition)} != 0){`, + `if ${writer.write(node.vCondition)} {`, writer.write(node.vTrueBody), - ...(node.vFalseBody ? ['}else{', writer.write(node.vFalseBody)] : []), + ...(node.vFalseBody ? ['} else {', writer.write(node.vFalseBody)] : []), '}', ] .filter(notUndefined) From a5aa3433d2533d1f6c908666f030fe0a424cfeb0 Mon Sep 17 00:00:00 2001 From: AlejandroLabourdette Date: Fri, 3 Mar 2023 10:27:20 -0500 Subject: [PATCH 08/26] update expression statement writer --- src/cairoWriter/writers/expressionStatementWriter.ts | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/cairoWriter/writers/expressionStatementWriter.ts b/src/cairoWriter/writers/expressionStatementWriter.ts index ec11d4a71..7a53df857 100644 --- a/src/cairoWriter/writers/expressionStatementWriter.ts +++ b/src/cairoWriter/writers/expressionStatementWriter.ts @@ -15,12 +15,12 @@ export class ExpressionStatementWriter extends CairoASTNodeWriter { writeInner(node: ExpressionStatement, writer: ASTWriter): SrcDesc { const documentation = getDocumentation(node.documentation, writer); if ( - node.vExpression instanceof FunctionCall && - node.vExpression.kind !== FunctionCallKind.StructConstructorCall + (node.vExpression instanceof FunctionCall && + node.vExpression.kind !== FunctionCallKind.StructConstructorCall) || + node.vExpression instanceof Assignment || + node.vExpression instanceof CairoAssert ) { return [[documentation, `${writer.write(node.vExpression)};`].join('\n')]; - } else if (node.vExpression instanceof Assignment || node.vExpression instanceof CairoAssert) { - return [[documentation, `${writer.write(node.vExpression)}`].join('\n')]; } else { return [ [ From c699de34f907106b7cded55f37218054c0e42ced Mon Sep 17 00:00:00 2001 From: AlejandroLabourdette Date: Fri, 3 Mar 2023 10:32:39 -0500 Subject: [PATCH 09/26] update event definition writer --- src/cairoWriter/writers/eventDefinitionWriter.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cairoWriter/writers/eventDefinitionWriter.ts b/src/cairoWriter/writers/eventDefinitionWriter.ts index 755dbca0f..3ae73242f 100644 --- a/src/cairoWriter/writers/eventDefinitionWriter.ts +++ b/src/cairoWriter/writers/eventDefinitionWriter.ts @@ -6,6 +6,6 @@ export class EventDefinitionWriter extends CairoASTNodeWriter { writeInner(node: EventDefinition, writer: ASTWriter): SrcDesc { const documentation = getDocumentation(node.documentation, writer); const args: string = writer.write(node.vParameters); - return [[documentation, `// @event`, `// func ${node.name}(${args}){`, `// }`].join('\n')]; + return [[documentation, `// #[event]`, `// fn ${node.name}(${args}) {}`].join('\n')]; } } From 190cd517ceb8d4e44d54ec65cde54208d1bbabbe Mon Sep 17 00:00:00 2001 From: AlejandroLabourdette Date: Fri, 3 Mar 2023 10:33:44 -0500 Subject: [PATCH 10/26] update cairo function definition writer --- .../writers/cairoFunctionDefinitionWriter.ts | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/src/cairoWriter/writers/cairoFunctionDefinitionWriter.ts b/src/cairoWriter/writers/cairoFunctionDefinitionWriter.ts index d542fe9da..a29d221b8 100644 --- a/src/cairoWriter/writers/cairoFunctionDefinitionWriter.ts +++ b/src/cairoWriter/writers/cairoFunctionDefinitionWriter.ts @@ -40,17 +40,16 @@ export class CairoFunctionDefinitionWriter extends CairoASTNodeWriter { const body = this.getBody(node, writer); const returns = this.getReturns(node, writer); - const implicits = this.getImplicits(node); return [ - [documentation, ...decorator, `func ${name}${implicits}(${args})${returns}{`, body, `}`] + [documentation, ...decorator, `fn ${name}(${args})${returns}{`, body, `}`] .filter(notNull) .join('\n'), ]; } private getDecorator(node: CairoFunctionDefinition): string[] { - if (node.kind === FunctionKind.Constructor) return ['@constructor']; + if (node.kind === FunctionKind.Constructor) return ['#[constructor]']; const decorators: string[] = []; if (node.kind === FunctionKind.Fallback) { decorators.push('@raw_input'); @@ -61,8 +60,8 @@ export class CairoFunctionDefinitionWriter extends CairoASTNodeWriter { if ( [FunctionStateMutability.Pure, FunctionStateMutability.View].includes(node.stateMutability) ) - decorators.push('@view'); - else decorators.push('@external'); + decorators.push('#[view]'); + else decorators.push('#[external]'); } return decorators; @@ -90,7 +89,6 @@ export class CairoFunctionDefinitionWriter extends CairoASTNodeWriter { if (!isExternallyVisible(node) || !node.implicits.has('warp_memory')) { return [ - 'alloc_locals;', this.getConstructorStorageAllocation(node), ...keccakPtrInit, withKeccak, @@ -105,7 +103,6 @@ export class CairoFunctionDefinitionWriter extends CairoASTNodeWriter { const keccakPtr = withKeccak !== '' ? ', keccak_ptr' : ''; return [ - 'alloc_locals;', this.getConstructorStorageAllocation(node), ...keccakPtrInit, 'let (local warp_memory : DictAccess*) = default_dict_new(0);', From ef661a56c5a9c73be3447836c28ec73cb925adee Mon Sep 17 00:00:00 2001 From: AlejandroLabourdette Date: Fri, 3 Mar 2023 10:40:49 -0500 Subject: [PATCH 11/26] update tempvar writer to just use let --- src/cairoWriter/writers/cairoTempVarWriter.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cairoWriter/writers/cairoTempVarWriter.ts b/src/cairoWriter/writers/cairoTempVarWriter.ts index 459259736..2218169bd 100644 --- a/src/cairoWriter/writers/cairoTempVarWriter.ts +++ b/src/cairoWriter/writers/cairoTempVarWriter.ts @@ -4,6 +4,6 @@ import { CairoASTNodeWriter } from '../base'; export class CairoTempVarWriter extends CairoASTNodeWriter { writeInner(node: CairoTempVarStatement, _writer: ASTWriter): SrcDesc { - return [`tempvar ${node.name} = ${node.name};`]; + return [`let ${node.name} = ${node.name};`]; } } From 4c665758b09759408e07ca45a2c1a288342e0c6b Mon Sep 17 00:00:00 2001 From: AlejandroLabourdette Date: Fri, 3 Mar 2023 11:35:37 -0500 Subject: [PATCH 12/26] move imports, util funcs, const and structs definition from SourceUnit to Contract writer --- .../writers/cairoContractWriter.ts | 104 ++++++++++++++++-- src/cairoWriter/writers/sourceUnitWriter.ts | 87 +-------------- src/freeStructWritter.ts | 11 +- 3 files changed, 101 insertions(+), 101 deletions(-) diff --git a/src/cairoWriter/writers/cairoContractWriter.ts b/src/cairoWriter/writers/cairoContractWriter.ts index 968fcf214..8b2c4500e 100644 --- a/src/cairoWriter/writers/cairoContractWriter.ts +++ b/src/cairoWriter/writers/cairoContractWriter.ts @@ -1,6 +1,11 @@ -import { ASTWriter, ContractKind, SrcDesc } from 'solc-typed-ast'; +import { ASTWriter, ContractKind, SourceUnit, SrcDesc } from 'solc-typed-ast'; import { isExternallyVisible } from '../../utils/utils'; -import { CairoContract } from '../../ast/cairoNodes'; +import { + CairoContract, + CairoGeneratedFunctionDefinition, + CairoImportFunctionDefinition, + FunctionStubKind, +} from '../../ast/cairoNodes'; import { TEMP_INTERFACE_SUFFIX } from '../../utils/nameModifiers'; import { CairoASTNodeWriter } from '../base'; import { @@ -10,6 +15,8 @@ import { INDENT, } from '../utils'; import { interfaceNameMappings } from './sourceUnitWriter'; +import assert from 'assert'; +import { getStructs } from '../../freeStructWritter'; export class CairoContractWriter extends CairoASTNodeWriter { writeInner(node: CairoContract, writer: ASTWriter): SrcDesc { @@ -56,7 +63,7 @@ export class CairoContractWriter extends CairoASTNodeWriter { .filter((func) => !isExternallyVisible(func)) .map((func) => writer.write(func)); - const events = node.vEvents.map((value) => writer.write(value)); + const events = node.vEvents.map((value) => writer.write(value)).join('\n\n'); const body = [...variables, ...enums, ...otherFunctions] .join('\n\n') @@ -114,21 +121,88 @@ export class CairoContractWriter extends CairoASTNodeWriter { '}', ] : []), - ].join('\n'); + ] + .map((l) => (l.length > 0 ? INDENT + l : l)) + .join('\n'); + + // Data about imports used, util funcs, constants and structs definition are stored in the Source Unit node + // but should be printed inside the contract module + const sourceUnit = node.parent; + assert(sourceUnit instanceof SourceUnit, 'Contract node parent should be a Source Unit node.'); + + // Only constants generated by `newToDeploy` exist at this stage + const constants = sourceUnit.vVariables + .map((v) => { + assert(v.vValue !== undefined, 'Constants cannot be unanssigned'); + return [`// ${v.documentation}`, `const ${v.name} = ${writer.write(v.vValue)};`].join('\n'); + }) + .join('\n'); + + const freeStructs = getStructs(sourceUnit, this.ast); + const structs = [...freeStructs, ...sourceUnit.vStructs, ...(node?.vStructs || [])] + .map((v) => writer.write(v)) + .join('\n\n'); + + const importFunctions = sourceUnit.vFunctions.filter( + (f): f is CairoImportFunctionDefinition => f instanceof CairoImportFunctionDefinition, + ); + const generatedFunctions = sourceUnit.vFunctions.filter( + (f): f is CairoGeneratedFunctionDefinition => f instanceof CairoGeneratedFunctionDefinition, + ); + const otherSourceUnitFunctions = sourceUnit.vFunctions.filter( + (f) => + !(f instanceof CairoGeneratedFunctionDefinition) && + !(f instanceof CairoImportFunctionDefinition), + ); + + const writtenImportFuncs = getGroupedImports( + importFunctions + .sort((funcA, funcB) => + `${funcA.path}.${funcA.name}`.localeCompare(`${funcB.path}.${funcB.name}`), + ) + .filter((func, index, importFuncs) => func.name !== importFuncs[index - 1]?.name), + ).reduce((writtenImports, importFunc) => `${writtenImports}\n${importFunc}`, ''); + + const writtenGeneratedFuncs = generatedFunctions + .sort((funcA, funcB) => funcA.name.localeCompare(funcB.name)) + .sort((funcA, funcB) => { + const stubA = funcA.functionStubKind; + const stubB = funcB.functionStubKind; + if (stubA === stubB) return 0; + if (stubA === FunctionStubKind.StructDefStub) return -1; + if (stubA === FunctionStubKind.StorageDefStub) return -1; + return 1; + }) + .filter((func, index, genFuncs) => func.name !== genFuncs[index - 1]?.name) + .map((func) => writer.write(func)) + .join('\n\n'); + + const writtenOtherSourceUnitFunctions = otherSourceUnitFunctions + .map((func) => writer.write(func)) + .join('\n\n'); + + const contractHeader = '#[contract] \n' + `mod ${node.name} {`; return [ [ + contractHeader, documentation, - ...events, - `namespace ${node.name}{\n\n${body}\n\n}`, - outsideNamespaceBody, + writtenImportFuncs, + constants, storageCode, + events, + structs, + body, + outsideNamespaceBody, + writtenGeneratedFuncs, + writtenOtherSourceUnitFunctions, + `}`, ].join('\n\n'), ]; } writeWhole(node: CairoContract, writer: ASTWriter): SrcDesc { - return [`// Contract Def ${node.name}\n\n${this.writeInner(node, writer)}`]; + return [`${this.writeInner(node, writer)}`]; } private writeContractInterface(node: CairoContract, writer: ASTWriter): SrcDesc { @@ -168,3 +242,17 @@ export class CairoContractWriter extends CairoASTNodeWriter { ]; } } + +function getGroupedImports(imports: CairoImportFunctionDefinition[]): string[] { + const processedImports: string[] = []; + imports.reduce((functionNames: string[], importNode, index) => { + functionNames.push(importNode.name); + if (importNode.path !== imports[index + 1]?.path) { + // TODO: multiple imports are not avaible in cairo1 + processedImports.push(`use ${importNode.path}::${functionNames.join(', ')}`); + functionNames = []; + } + return functionNames; + }, []); + return processedImports; +} diff --git a/src/cairoWriter/writers/sourceUnitWriter.ts b/src/cairoWriter/writers/sourceUnitWriter.ts index f936f9743..50ac26cc8 100644 --- a/src/cairoWriter/writers/sourceUnitWriter.ts +++ b/src/cairoWriter/writers/sourceUnitWriter.ts @@ -1,11 +1,5 @@ import assert from 'assert'; import { ASTWriter, ContractKind, SourceUnit, SrcDesc } from 'solc-typed-ast'; -import { - CairoImportFunctionDefinition, - CairoGeneratedFunctionDefinition, - FunctionStubKind, -} from '../../ast/cairoNodes'; -import { getStructsAndRemappings } from '../../freeStructWritter'; import { removeExcessNewlines } from '../../utils/formatting'; import { TEMP_INTERFACE_SUFFIX } from '../../utils/nameModifiers'; import { CairoASTNodeWriter } from '../base'; @@ -27,75 +21,13 @@ export class SourceUnitWriter extends CairoASTNodeWriter { ? node.vContracts.filter((cd) => !cd.name.endsWith(TEMP_INTERFACE_SUFFIX)) : node.vContracts; - assert(mainContract_.length <= 1); - const [mainContract] = mainContract_; + assert(mainContract_.length <= 1, 'Every SourceUnit should only define a single contract'); - const [freeStructs, freeStructRemappings_] = mainContract - ? getStructsAndRemappings(node, this.ast) - : [[], new Map()]; - structRemappings = freeStructRemappings_; - - // Only constants generated by `newToDeploy` exist at this stage - const constants = node.vVariables.flatMap((v) => { - assert(v.vValue !== undefined, 'Constants cannot be unanssigned'); - return [`// ${v.documentation}`, `const ${v.name} = ${writer.write(v.vValue)};`].join('\n'); - }); - - const structs = [...freeStructs, ...node.vStructs, ...(mainContract?.vStructs || [])].map((v) => - writer.write(v), - ); - - const importFunctions = node.vFunctions.filter( - (f): f is CairoImportFunctionDefinition => f instanceof CairoImportFunctionDefinition, - ); - const generatedFunctions = node.vFunctions.filter( - (f): f is CairoGeneratedFunctionDefinition => f instanceof CairoGeneratedFunctionDefinition, - ); - const functions = node.vFunctions.filter( - (f) => - !(f instanceof CairoGeneratedFunctionDefinition) && - !(f instanceof CairoImportFunctionDefinition), - ); - - const writtenImportFuncs = getGroupedImports( - importFunctions - .sort((funcA, funcB) => - `${funcA.path}.${funcA.name}`.localeCompare(`${funcB.path}.${funcB.name}`), - ) - .filter((func, index, importFuncs) => func.name !== importFuncs[index - 1]?.name), - ).reduce((writtenImports, importFunc) => `${writtenImports}\n${importFunc}`, ''); - - const writtenGeneratedFuncs = generatedFunctions - .sort((funcA, funcB) => funcA.name.localeCompare(funcB.name)) - .sort((funcA, funcB) => { - const stubA = funcA.functionStubKind; - const stubB = funcB.functionStubKind; - if (stubA === stubB) return 0; - if (stubA === FunctionStubKind.StructDefStub) return -1; - if (stubA === FunctionStubKind.StorageDefStub) return -1; - return 1; - }) - .filter((func, index, genFuncs) => func.name !== genFuncs[index - 1]?.name) - .map((func) => writer.write(func)); - - const writtenFuncs = functions.map((func) => writer.write(func)); + structRemappings = new Map(); const contracts = node.vContracts.map((v) => writer.write(v)); - return [ - removeExcessNewlines( - [ - '%lang starknet', - writtenImportFuncs, - ...constants, - ...structs, - ...writtenGeneratedFuncs, - ...writtenFuncs, - ...contracts, - ].join('\n\n\n'), - 3, - ), - ]; + return [removeExcessNewlines([...contracts].join('\n\n\n'), 3)]; } private generateInterfaceNameMappings(node: SourceUnit) { @@ -121,16 +53,3 @@ export class SourceUnitWriter extends CairoASTNodeWriter { interfaceNameMappings.set(node, map); } } - -function getGroupedImports(imports: CairoImportFunctionDefinition[]): string[] { - const processedImports: string[] = []; - imports.reduce((functionNames: string[], importNode, index) => { - functionNames.push(importNode.name); - if (importNode.path !== imports[index + 1]?.path) { - processedImports.push(`from ${importNode.path} import ${functionNames.join(', ')}`); - functionNames = []; - } - return functionNames; - }, []); - return processedImports; -} diff --git a/src/freeStructWritter.ts b/src/freeStructWritter.ts index 588bdcfcc..0e6f53f36 100644 --- a/src/freeStructWritter.ts +++ b/src/freeStructWritter.ts @@ -18,16 +18,9 @@ import { makeStructTree, reorderStructs } from './passes/orderNestedStructs'; function which do that. */ -export function getStructsAndRemappings( - node: SourceUnit, - ast: AST, -): [StructDefinition[], Map] { - // Stores old FunctionDefinition and cloned FunctionDefinition - const remappings = new Map(); - +export function getStructs(node: SourceUnit, ast: AST): StructDefinition[] { const externalStructs = getDefinitionsToInline(node, node, new Set()); - - return [reorderStructs(...makeStructTree(externalStructs, ast)), remappings]; + return reorderStructs(...makeStructTree(externalStructs, ast)); } // DFS a node for definitions in a free context. From 426bc870785e9a86a42356bccd001b57104e04ab Mon Sep 17 00:00:00 2001 From: AlejandroLabourdette Date: Tue, 7 Mar 2023 02:12:42 -0500 Subject: [PATCH 13/26] convert felts to uint --- src/cairoWriter/writers/assignmentWriter.ts | 13 ------------ src/cairoWriter/writers/literalWriter.ts | 22 +++++++++++++++++++-- src/passes/cairoUtilImporter.ts | 2 +- src/utils/importFuncGenerator.ts | 3 +++ 4 files changed, 24 insertions(+), 16 deletions(-) diff --git a/src/cairoWriter/writers/assignmentWriter.ts b/src/cairoWriter/writers/assignmentWriter.ts index c33d5b39e..56b54b54e 100644 --- a/src/cairoWriter/writers/assignmentWriter.ts +++ b/src/cairoWriter/writers/assignmentWriter.ts @@ -8,19 +8,6 @@ export class AssignmentWriter extends CairoASTNodeWriter { assert(node.operator === '=', `Unexpected operator ${node.operator}`); const [lhs, rhs] = [node.vLeftHandSide, node.vRightHandSide]; const nodes = [lhs, rhs].map((v) => writer.write(v)); - // This is specifically needed because of the construtions involved with writing - // conditionals (derived from short circuit expressions). Other tuple assignments - // and function call assignments will have been split - if ( - rhs instanceof FunctionCall && - !( - rhs.vReferencedDeclaration instanceof CairoFunctionDefinition && - rhs.vReferencedDeclaration.functionStubKind === FunctionStubKind.StructDefStub - ) && - !(lhs instanceof TupleExpression) - ) { - return [`let ${nodes[0]} ${node.operator} ${nodes[1]};`]; - } return [`let ${nodes[0]} ${node.operator} ${nodes[1]};`]; } } diff --git a/src/cairoWriter/writers/literalWriter.ts b/src/cairoWriter/writers/literalWriter.ts index c12d5a69c..72eddb1cb 100644 --- a/src/cairoWriter/writers/literalWriter.ts +++ b/src/cairoWriter/writers/literalWriter.ts @@ -1,11 +1,21 @@ import { ASTWriter, Literal, LiteralKind, SrcDesc } from 'solc-typed-ast'; +import { TranspileFailedError } from '../../utils/errors'; +import { primitiveTypeToCairo } from '../../utils/utils'; import { CairoASTNodeWriter } from '../base'; export class LiteralWriter extends CairoASTNodeWriter { writeInner(node: Literal, _: ASTWriter): SrcDesc { switch (node.kind) { case LiteralKind.Number: - return [node.value]; + switch (primitiveTypeToCairo(node.typeString)) { + case 'Uint256': { + return [`u256_from_felt(${node.value})`]; + } + case 'felt': + return [node.value]; + default: + throw new TranspileFailedError('Attempted to write unexpected cairo type'); + } case LiteralKind.Bool: return [node.value === 'true' ? '1' : '0']; case LiteralKind.String: @@ -20,7 +30,15 @@ export class LiteralWriter extends CairoASTNodeWriter { return [`0x${node.hexValue}`]; } case LiteralKind.HexString: - return [`0x${node.hexValue}`]; + switch (primitiveTypeToCairo(node.typeString)) { + case 'Uint256': { + return [`u256_from_felt(0x${node.hexValue})`]; + } + case 'felt': + return [`0x${node.hexValue}`]; + default: + throw new TranspileFailedError('Attempted to write unexpected cairo type'); + } } } } diff --git a/src/passes/cairoUtilImporter.ts b/src/passes/cairoUtilImporter.ts index 5fab01fd3..85f63a7bd 100644 --- a/src/passes/cairoUtilImporter.ts +++ b/src/passes/cairoUtilImporter.ts @@ -39,7 +39,7 @@ export class CairoUtilImporter extends ASTMapper { visitLiteral(node: Literal, ast: AST): void { const type = safeGetNodeType(node, ast.inference); if (type instanceof IntType && type.nBits > 251) { - createImport('starkware.cairo.common.uint256', 'Uint256', this.dummySourceUnit ?? node, ast); + createImport('integer', 'u256_from_felt', this.dummySourceUnit ?? node, ast); } } diff --git a/src/utils/importFuncGenerator.ts b/src/utils/importFuncGenerator.ts index 93f6530e8..6c3d8648f 100644 --- a/src/utils/importFuncGenerator.ts +++ b/src/utils/importFuncGenerator.ts @@ -116,6 +116,9 @@ export function createImport( return createFuncImport('syscall_ptr'); case STARKWARE_STARKNET_COMMON_SYSCALLS + 'get_contract_address': return createFuncImport('syscall_ptr'); + // Import libraries from Cairo1 + case 'integer' + 'u256_from_felt': + return createFuncImport(); default: throw new TranspileFailedError(`Import ${name} from ${path} is not defined.`); } From 7cac76b84acb2e3bfed489338eb58837a3670f52 Mon Sep 17 00:00:00 2001 From: AlejandroLabourdette Date: Tue, 7 Mar 2023 12:49:32 -0500 Subject: [PATCH 14/26] create u256 from 2 felts --- warplib/integer.cairo | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 warplib/integer.cairo diff --git a/warplib/integer.cairo b/warplib/integer.cairo new file mode 100644 index 000000000..071a87cef --- /dev/null +++ b/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(); +} + From a4621b5acc577cc74725b923bdac8ddb7c6b75e7 Mon Sep 17 00:00:00 2001 From: AlejandroLabourdette Date: Tue, 7 Mar 2023 13:08:41 -0500 Subject: [PATCH 15/26] use u256_from_felts to create u256 values --- src/cairoWriter/writers/literalWriter.ts | 9 ++++++--- src/passes/cairoUtilImporter.ts | 2 +- src/utils/importFuncGenerator.ts | 2 +- 3 files changed, 8 insertions(+), 5 deletions(-) diff --git a/src/cairoWriter/writers/literalWriter.ts b/src/cairoWriter/writers/literalWriter.ts index 72eddb1cb..e7d2d50ca 100644 --- a/src/cairoWriter/writers/literalWriter.ts +++ b/src/cairoWriter/writers/literalWriter.ts @@ -1,6 +1,6 @@ import { ASTWriter, Literal, LiteralKind, SrcDesc } from 'solc-typed-ast'; import { TranspileFailedError } from '../../utils/errors'; -import { primitiveTypeToCairo } from '../../utils/utils'; +import { divmod, primitiveTypeToCairo } from '../../utils/utils'; import { CairoASTNodeWriter } from '../base'; export class LiteralWriter extends CairoASTNodeWriter { @@ -9,7 +9,8 @@ export class LiteralWriter extends CairoASTNodeWriter { case LiteralKind.Number: switch (primitiveTypeToCairo(node.typeString)) { case 'Uint256': { - return [`u256_from_felt(${node.value})`]; + const [high, low] = divmod(BigInt(node.value), BigInt(Math.pow(2, 128))); + return [`u256_from_felts( ${low}, ${high} )`]; } case 'felt': return [node.value]; @@ -32,7 +33,9 @@ export class LiteralWriter extends CairoASTNodeWriter { case LiteralKind.HexString: switch (primitiveTypeToCairo(node.typeString)) { case 'Uint256': { - return [`u256_from_felt(0x${node.hexValue})`]; + return [ + `u256_from_felts( ${node.hexValue.slice(32, 64)}, ${node.hexValue.slice(0, 32)} )`, + ]; } case 'felt': return [`0x${node.hexValue}`]; diff --git a/src/passes/cairoUtilImporter.ts b/src/passes/cairoUtilImporter.ts index 85f63a7bd..33eff7831 100644 --- a/src/passes/cairoUtilImporter.ts +++ b/src/passes/cairoUtilImporter.ts @@ -39,7 +39,7 @@ export class CairoUtilImporter extends ASTMapper { visitLiteral(node: Literal, ast: AST): void { const type = safeGetNodeType(node, ast.inference); if (type instanceof IntType && type.nBits > 251) { - createImport('integer', 'u256_from_felt', this.dummySourceUnit ?? node, ast); + createImport('integer', 'u256_from_felts', this.dummySourceUnit ?? node, ast); } } diff --git a/src/utils/importFuncGenerator.ts b/src/utils/importFuncGenerator.ts index 6c3d8648f..6fbe7472a 100644 --- a/src/utils/importFuncGenerator.ts +++ b/src/utils/importFuncGenerator.ts @@ -117,7 +117,7 @@ export function createImport( case STARKWARE_STARKNET_COMMON_SYSCALLS + 'get_contract_address': return createFuncImport('syscall_ptr'); // Import libraries from Cairo1 - case 'integer' + 'u256_from_felt': + case 'integer' + 'u256_from_felts': return createFuncImport(); default: throw new TranspileFailedError(`Import ${name} from ${path} is not defined.`); From 2b2c88996b7fb72cf4b96c179f286245239d2d32 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Piwo=C5=84ski?= Date: Tue, 7 Mar 2023 23:55:19 +0100 Subject: [PATCH 16/26] Fix linting errors --- src/cairoWriter/writers/assignmentWriter.ts | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/cairoWriter/writers/assignmentWriter.ts b/src/cairoWriter/writers/assignmentWriter.ts index 56b54b54e..ea71b4342 100644 --- a/src/cairoWriter/writers/assignmentWriter.ts +++ b/src/cairoWriter/writers/assignmentWriter.ts @@ -1,6 +1,5 @@ import assert from 'assert'; -import { Assignment, ASTWriter, FunctionCall, SrcDesc, TupleExpression } from 'solc-typed-ast'; -import { CairoFunctionDefinition, FunctionStubKind } from '../../ast/cairoNodes'; +import { Assignment, ASTWriter, SrcDesc } from 'solc-typed-ast'; import { CairoASTNodeWriter } from '../base'; export class AssignmentWriter extends CairoASTNodeWriter { From 4ddaa554b893ddc7f17574dddb06af3b3d9b0679 Mon Sep 17 00:00:00 2001 From: Carmen Cabrera Date: Wed, 8 Mar 2023 02:40:01 -0500 Subject: [PATCH 17/26] add import to get u256 from felts --- src/passes/cairoUtilImporter.ts | 3 ++- src/utils/importFuncGenerator.ts | 3 ++- src/utils/importPaths.ts | 1 + 3 files changed, 5 insertions(+), 2 deletions(-) diff --git a/src/passes/cairoUtilImporter.ts b/src/passes/cairoUtilImporter.ts index 7b6ad7a14..6b42d6d1e 100644 --- a/src/passes/cairoUtilImporter.ts +++ b/src/passes/cairoUtilImporter.ts @@ -17,6 +17,7 @@ import { DEFAULT_DICT_NEW, DICT_WRITE, FINALIZE_KECCAK, + U256_FROM_FELTS, UINT256, } from '../utils/importPaths'; import { safeGetNodeType } from '../utils/nodeTypeProcessing'; @@ -47,7 +48,7 @@ export class CairoUtilImporter extends ASTMapper { visitLiteral(node: Literal, ast: AST): void { const type = safeGetNodeType(node, ast.inference); if (type instanceof IntType && type.nBits > 251) { - createImport(['integer'], 'u256_from_felts', this.dummySourceUnit ?? node, ast); + createImport(...U256_FROM_FELTS, this.dummySourceUnit ?? node, ast); } } diff --git a/src/utils/importFuncGenerator.ts b/src/utils/importFuncGenerator.ts index fd3fb5f42..57f12ec7c 100644 --- a/src/utils/importFuncGenerator.ts +++ b/src/utils/importFuncGenerator.ts @@ -27,6 +27,7 @@ import { IS_LE, IS_LE_FELT, SPLIT_FELT, + U256_FROM_FELTS, UINT256, UINT256_ADD, UINT256_EQ, @@ -118,7 +119,7 @@ export function createImport( case encodePath(GET_CONTRACT_ADDRESS): return createFuncImport('syscall_ptr'); // Import libraries from Cairo1 - case 'integer' + 'u256_from_felts': + case encodePath(U256_FROM_FELTS): return createFuncImport(); default: throw new TranspileFailedError(`Import ${name} from ${path} is not defined.`); diff --git a/src/utils/importPaths.ts b/src/utils/importPaths.ts index a51f72f74..bfcba3f72 100644 --- a/src/utils/importPaths.ts +++ b/src/utils/importPaths.ts @@ -106,3 +106,4 @@ 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']; From 3999f1bfd438c171e140a8a0552afe90944f60e7 Mon Sep 17 00:00:00 2001 From: Carmen Cabrera Date: Wed, 8 Mar 2023 02:48:17 -0500 Subject: [PATCH 18/26] add missing semicolon at the end of imports --- src/cairoWriter/writers/cairoImportFunctionDefinitionWriter.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cairoWriter/writers/cairoImportFunctionDefinitionWriter.ts b/src/cairoWriter/writers/cairoImportFunctionDefinitionWriter.ts index af6e0c30a..2bc917ccf 100644 --- a/src/cairoWriter/writers/cairoImportFunctionDefinitionWriter.ts +++ b/src/cairoWriter/writers/cairoImportFunctionDefinitionWriter.ts @@ -5,6 +5,6 @@ import { CairoASTNodeWriter } from '../base'; // Not being used as for now export class CairoImportFunctionDefinitionWriter extends CairoASTNodeWriter { writeInner(node: CairoImportFunctionDefinition, _writer: ASTWriter): SrcDesc { - return [`use ${[...node.path, node.name].join('::')}`]; + return [`use ${[...node.path, node.name].join('::')};`]; } } From d73c7bafa5681179ac844287122e120a18593e89 Mon Sep 17 00:00:00 2001 From: Carmen Cabrera Date: Wed, 8 Mar 2023 02:56:53 -0500 Subject: [PATCH 19/26] remove unnecessary semicolon in cairoAssert CairoAssert node is an expression, hence it appears as a statement only as a child of ExpressionStatement. The writer for this node already adds the semicolon. --- src/cairoWriter/writers/cairoAssertWriter.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cairoWriter/writers/cairoAssertWriter.ts b/src/cairoWriter/writers/cairoAssertWriter.ts index 6bd4a4922..f87a04ca8 100644 --- a/src/cairoWriter/writers/cairoAssertWriter.ts +++ b/src/cairoWriter/writers/cairoAssertWriter.ts @@ -6,6 +6,6 @@ export class CairoAssertWriter extends CairoASTNodeWriter { writeInner(node: CairoAssert, writer: ASTWriter): SrcDesc { const expression = writer.write(node.vExpression); const message = node.assertMessage ?? 'Assertion error'; - return [`assert( ${expression}, "${message}" );`]; + return [`assert( ${expression}, "${message}" )`]; } } From 2e8318d47a7111ae0d6ee3ce60ad7fa5ece33d59 Mon Sep 17 00:00:00 2001 From: Carmen Cabrera Date: Wed, 8 Mar 2023 03:05:03 -0500 Subject: [PATCH 20/26] fix typo in mapping generated info --- src/cairoUtilFuncGen/storage/mappingIndexAccess.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cairoUtilFuncGen/storage/mappingIndexAccess.ts b/src/cairoUtilFuncGen/storage/mappingIndexAccess.ts index 5c99a09f6..eb1e46e60 100644 --- a/src/cairoUtilFuncGen/storage/mappingIndexAccess.ts +++ b/src/cairoUtilFuncGen/storage/mappingIndexAccess.ts @@ -114,7 +114,7 @@ export class MappingIndexAccessGen extends CairoUtilFuncGenBase { const mappingFuncInfo: GeneratedFunctionInfo = { name: mappingName, - code: `${mappingName}: LegacyMap::<(felt, ${indexTypeString}), felt}>`, + code: `${mappingName}: LegacyMap::<(felt, ${indexTypeString}), felt>`, functionsCalled: [], }; const mappingFunc = createCairoGeneratedFunction( From 6b3ab5d88c8437f93ef9ed83c18fdc8518388593 Mon Sep 17 00:00:00 2001 From: Carmen Cabrera Date: Wed, 8 Mar 2023 03:15:35 -0500 Subject: [PATCH 21/26] fix assertion error messsage --- src/cairoWriter/writers/cairoAssertWriter.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cairoWriter/writers/cairoAssertWriter.ts b/src/cairoWriter/writers/cairoAssertWriter.ts index f87a04ca8..de4adc04e 100644 --- a/src/cairoWriter/writers/cairoAssertWriter.ts +++ b/src/cairoWriter/writers/cairoAssertWriter.ts @@ -6,6 +6,6 @@ export class CairoAssertWriter extends CairoASTNodeWriter { writeInner(node: CairoAssert, writer: ASTWriter): SrcDesc { const expression = writer.write(node.vExpression); const message = node.assertMessage ?? 'Assertion error'; - return [`assert( ${expression}, "${message}" )`]; + return [`assert( ${expression}, '${message}' )`]; } } From 6b87dc0633e00d969b292ef4a162474950ec9e0e Mon Sep 17 00:00:00 2001 From: Carmen Cabrera Date: Wed, 8 Mar 2023 03:16:37 -0500 Subject: [PATCH 22/26] rename cairo1 binary for linux folder --- cairo1/{linux_64 => linux_x64}/.DS_Store | Bin cairo1/{linux_64 => linux_x64}/bin/cairo-compile | Bin cairo1/{linux_64 => linux_x64}/bin/cairo-format | Bin .../bin/cairo-language-server | Bin cairo1/{linux_64 => linux_x64}/bin/cairo-run | Bin cairo1/{linux_64 => linux_x64}/bin/cairo-test | Bin cairo1/{linux_64 => linux_x64}/bin/sierra-compile | Bin cairo1/{linux_64 => linux_x64}/bin/starknet-compile | Bin .../bin/starknet-sierra-compile | Bin cairo1/{linux_64 => linux_x64}/corelib/.DS_Store | Bin cairo1/{linux_64 => linux_x64}/corelib/Scarb.toml | 0 .../corelib/cairo_project.toml | 0 .../{linux_64 => linux_x64}/corelib/src/.DS_Store | Bin .../{linux_64 => linux_x64}/corelib/src/array.cairo | 0 .../{linux_64 => linux_x64}/corelib/src/box.cairo | 0 .../{linux_64 => linux_x64}/corelib/src/debug.cairo | 0 .../{linux_64 => linux_x64}/corelib/src/dict.cairo | 0 cairo1/{linux_64 => linux_x64}/corelib/src/ec.cairo | 0 .../{linux_64 => linux_x64}/corelib/src/ecdsa.cairo | 0 .../{linux_64 => linux_x64}/corelib/src/gas.cairo | 0 .../{linux_64 => linux_x64}/corelib/src/hash.cairo | 0 .../corelib/src/integer.cairo | 0 .../corelib/src/internal.cairo | 0 .../{linux_64 => linux_x64}/corelib/src/lib.cairo | 0 .../corelib/src/nullable.cairo | 0 .../corelib/src/option.cairo | 0 .../corelib/src/result.cairo | 0 .../{linux_64 => linux_x64}/corelib/src/serde.cairo | 0 .../{linux_64 => linux_x64}/corelib/src/span.cairo | 0 .../corelib/src/starknet.cairo | 0 .../corelib/src/starknet/contract_address.cairo | 0 .../corelib/src/starknet/storage_access.cairo | 0 .../corelib/src/starknet_serde.cairo | 0 .../corelib/src/starknet_testing.cairo | 0 .../{linux_64 => linux_x64}/corelib/src/test.cairo | 0 .../corelib/src/traits.cairo | 0 .../corelib/src/zeroable.cairo | 0 37 files changed, 0 insertions(+), 0 deletions(-) rename cairo1/{linux_64 => linux_x64}/.DS_Store (100%) rename cairo1/{linux_64 => linux_x64}/bin/cairo-compile (100%) rename cairo1/{linux_64 => linux_x64}/bin/cairo-format (100%) rename cairo1/{linux_64 => linux_x64}/bin/cairo-language-server (100%) rename cairo1/{linux_64 => linux_x64}/bin/cairo-run (100%) rename cairo1/{linux_64 => linux_x64}/bin/cairo-test (100%) rename cairo1/{linux_64 => linux_x64}/bin/sierra-compile (100%) rename cairo1/{linux_64 => linux_x64}/bin/starknet-compile (100%) rename cairo1/{linux_64 => linux_x64}/bin/starknet-sierra-compile (100%) rename cairo1/{linux_64 => linux_x64}/corelib/.DS_Store (100%) rename cairo1/{linux_64 => linux_x64}/corelib/Scarb.toml (100%) rename cairo1/{linux_64 => linux_x64}/corelib/cairo_project.toml (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/.DS_Store (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/array.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/box.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/debug.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/dict.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/ec.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/ecdsa.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/gas.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/hash.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/integer.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/internal.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/lib.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/nullable.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/option.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/result.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/serde.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/span.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/starknet.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/starknet/contract_address.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/starknet/storage_access.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/starknet_serde.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/starknet_testing.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/test.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/traits.cairo (100%) rename cairo1/{linux_64 => linux_x64}/corelib/src/zeroable.cairo (100%) diff --git a/cairo1/linux_64/.DS_Store b/cairo1/linux_x64/.DS_Store similarity index 100% rename from cairo1/linux_64/.DS_Store rename to cairo1/linux_x64/.DS_Store diff --git a/cairo1/linux_64/bin/cairo-compile b/cairo1/linux_x64/bin/cairo-compile similarity index 100% rename from cairo1/linux_64/bin/cairo-compile rename to cairo1/linux_x64/bin/cairo-compile diff --git a/cairo1/linux_64/bin/cairo-format b/cairo1/linux_x64/bin/cairo-format similarity index 100% rename from cairo1/linux_64/bin/cairo-format rename to cairo1/linux_x64/bin/cairo-format diff --git a/cairo1/linux_64/bin/cairo-language-server b/cairo1/linux_x64/bin/cairo-language-server similarity index 100% rename from cairo1/linux_64/bin/cairo-language-server rename to cairo1/linux_x64/bin/cairo-language-server diff --git a/cairo1/linux_64/bin/cairo-run b/cairo1/linux_x64/bin/cairo-run similarity index 100% rename from cairo1/linux_64/bin/cairo-run rename to cairo1/linux_x64/bin/cairo-run diff --git a/cairo1/linux_64/bin/cairo-test b/cairo1/linux_x64/bin/cairo-test similarity index 100% rename from cairo1/linux_64/bin/cairo-test rename to cairo1/linux_x64/bin/cairo-test diff --git a/cairo1/linux_64/bin/sierra-compile b/cairo1/linux_x64/bin/sierra-compile similarity index 100% rename from cairo1/linux_64/bin/sierra-compile rename to cairo1/linux_x64/bin/sierra-compile diff --git a/cairo1/linux_64/bin/starknet-compile b/cairo1/linux_x64/bin/starknet-compile similarity index 100% rename from cairo1/linux_64/bin/starknet-compile rename to cairo1/linux_x64/bin/starknet-compile diff --git a/cairo1/linux_64/bin/starknet-sierra-compile b/cairo1/linux_x64/bin/starknet-sierra-compile similarity index 100% rename from cairo1/linux_64/bin/starknet-sierra-compile rename to cairo1/linux_x64/bin/starknet-sierra-compile diff --git a/cairo1/linux_64/corelib/.DS_Store b/cairo1/linux_x64/corelib/.DS_Store similarity index 100% rename from cairo1/linux_64/corelib/.DS_Store rename to cairo1/linux_x64/corelib/.DS_Store diff --git a/cairo1/linux_64/corelib/Scarb.toml b/cairo1/linux_x64/corelib/Scarb.toml similarity index 100% rename from cairo1/linux_64/corelib/Scarb.toml rename to cairo1/linux_x64/corelib/Scarb.toml diff --git a/cairo1/linux_64/corelib/cairo_project.toml b/cairo1/linux_x64/corelib/cairo_project.toml similarity index 100% rename from cairo1/linux_64/corelib/cairo_project.toml rename to cairo1/linux_x64/corelib/cairo_project.toml diff --git a/cairo1/linux_64/corelib/src/.DS_Store b/cairo1/linux_x64/corelib/src/.DS_Store similarity index 100% rename from cairo1/linux_64/corelib/src/.DS_Store rename to cairo1/linux_x64/corelib/src/.DS_Store diff --git a/cairo1/linux_64/corelib/src/array.cairo b/cairo1/linux_x64/corelib/src/array.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/array.cairo rename to cairo1/linux_x64/corelib/src/array.cairo diff --git a/cairo1/linux_64/corelib/src/box.cairo b/cairo1/linux_x64/corelib/src/box.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/box.cairo rename to cairo1/linux_x64/corelib/src/box.cairo diff --git a/cairo1/linux_64/corelib/src/debug.cairo b/cairo1/linux_x64/corelib/src/debug.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/debug.cairo rename to cairo1/linux_x64/corelib/src/debug.cairo diff --git a/cairo1/linux_64/corelib/src/dict.cairo b/cairo1/linux_x64/corelib/src/dict.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/dict.cairo rename to cairo1/linux_x64/corelib/src/dict.cairo diff --git a/cairo1/linux_64/corelib/src/ec.cairo b/cairo1/linux_x64/corelib/src/ec.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/ec.cairo rename to cairo1/linux_x64/corelib/src/ec.cairo diff --git a/cairo1/linux_64/corelib/src/ecdsa.cairo b/cairo1/linux_x64/corelib/src/ecdsa.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/ecdsa.cairo rename to cairo1/linux_x64/corelib/src/ecdsa.cairo diff --git a/cairo1/linux_64/corelib/src/gas.cairo b/cairo1/linux_x64/corelib/src/gas.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/gas.cairo rename to cairo1/linux_x64/corelib/src/gas.cairo diff --git a/cairo1/linux_64/corelib/src/hash.cairo b/cairo1/linux_x64/corelib/src/hash.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/hash.cairo rename to cairo1/linux_x64/corelib/src/hash.cairo diff --git a/cairo1/linux_64/corelib/src/integer.cairo b/cairo1/linux_x64/corelib/src/integer.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/integer.cairo rename to cairo1/linux_x64/corelib/src/integer.cairo diff --git a/cairo1/linux_64/corelib/src/internal.cairo b/cairo1/linux_x64/corelib/src/internal.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/internal.cairo rename to cairo1/linux_x64/corelib/src/internal.cairo diff --git a/cairo1/linux_64/corelib/src/lib.cairo b/cairo1/linux_x64/corelib/src/lib.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/lib.cairo rename to cairo1/linux_x64/corelib/src/lib.cairo diff --git a/cairo1/linux_64/corelib/src/nullable.cairo b/cairo1/linux_x64/corelib/src/nullable.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/nullable.cairo rename to cairo1/linux_x64/corelib/src/nullable.cairo diff --git a/cairo1/linux_64/corelib/src/option.cairo b/cairo1/linux_x64/corelib/src/option.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/option.cairo rename to cairo1/linux_x64/corelib/src/option.cairo diff --git a/cairo1/linux_64/corelib/src/result.cairo b/cairo1/linux_x64/corelib/src/result.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/result.cairo rename to cairo1/linux_x64/corelib/src/result.cairo diff --git a/cairo1/linux_64/corelib/src/serde.cairo b/cairo1/linux_x64/corelib/src/serde.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/serde.cairo rename to cairo1/linux_x64/corelib/src/serde.cairo diff --git a/cairo1/linux_64/corelib/src/span.cairo b/cairo1/linux_x64/corelib/src/span.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/span.cairo rename to cairo1/linux_x64/corelib/src/span.cairo diff --git a/cairo1/linux_64/corelib/src/starknet.cairo b/cairo1/linux_x64/corelib/src/starknet.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/starknet.cairo rename to cairo1/linux_x64/corelib/src/starknet.cairo diff --git a/cairo1/linux_64/corelib/src/starknet/contract_address.cairo b/cairo1/linux_x64/corelib/src/starknet/contract_address.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/starknet/contract_address.cairo rename to cairo1/linux_x64/corelib/src/starknet/contract_address.cairo diff --git a/cairo1/linux_64/corelib/src/starknet/storage_access.cairo b/cairo1/linux_x64/corelib/src/starknet/storage_access.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/starknet/storage_access.cairo rename to cairo1/linux_x64/corelib/src/starknet/storage_access.cairo diff --git a/cairo1/linux_64/corelib/src/starknet_serde.cairo b/cairo1/linux_x64/corelib/src/starknet_serde.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/starknet_serde.cairo rename to cairo1/linux_x64/corelib/src/starknet_serde.cairo diff --git a/cairo1/linux_64/corelib/src/starknet_testing.cairo b/cairo1/linux_x64/corelib/src/starknet_testing.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/starknet_testing.cairo rename to cairo1/linux_x64/corelib/src/starknet_testing.cairo diff --git a/cairo1/linux_64/corelib/src/test.cairo b/cairo1/linux_x64/corelib/src/test.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/test.cairo rename to cairo1/linux_x64/corelib/src/test.cairo diff --git a/cairo1/linux_64/corelib/src/traits.cairo b/cairo1/linux_x64/corelib/src/traits.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/traits.cairo rename to cairo1/linux_x64/corelib/src/traits.cairo diff --git a/cairo1/linux_64/corelib/src/zeroable.cairo b/cairo1/linux_x64/corelib/src/zeroable.cairo similarity index 100% rename from cairo1/linux_64/corelib/src/zeroable.cairo rename to cairo1/linux_x64/corelib/src/zeroable.cairo From 46bda7b44482d6d8cb28964b6d5103c58f9921c8 Mon Sep 17 00:00:00 2001 From: Carmen Cabrera Date: Wed, 8 Mar 2023 03:41:15 -0500 Subject: [PATCH 23/26] no need to replace identifiers with contract member access --- src/transpiler.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/src/transpiler.ts b/src/transpiler.ts index 9357917db..e99f1b9a1 100644 --- a/src/transpiler.ts +++ b/src/transpiler.ts @@ -153,7 +153,6 @@ function applyPasses( ['An', AnnotateImplicits], ['Lv', IfStatementTempVarPostpender], ['Ci', CairoUtilImporter], - ['Rim', ReplaceIdentifierContractMemberAccess], ['Dus', DropUnusedSourceUnits], ['Cs', CairoStubProcessor], ]); From b9c46b97d1b7463249dcd23344c2f964dc5f3c2a Mon Sep 17 00:00:00 2001 From: Carmen Cabrera Date: Mon, 13 Mar 2023 09:22:12 -0400 Subject: [PATCH 24/26] remove unused import and spaces --- src/cairoWriter/writers/cairoAssertWriter.ts | 2 +- src/transpiler.ts | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/src/cairoWriter/writers/cairoAssertWriter.ts b/src/cairoWriter/writers/cairoAssertWriter.ts index de4adc04e..f2a0db46c 100644 --- a/src/cairoWriter/writers/cairoAssertWriter.ts +++ b/src/cairoWriter/writers/cairoAssertWriter.ts @@ -6,6 +6,6 @@ export class CairoAssertWriter extends CairoASTNodeWriter { writeInner(node: CairoAssert, writer: ASTWriter): SrcDesc { const expression = writer.write(node.vExpression); const message = node.assertMessage ?? 'Assertion error'; - return [`assert( ${expression}, '${message}' )`]; + return [`assert(${expression}, '${message}')`]; } } diff --git a/src/transpiler.ts b/src/transpiler.ts index e99f1b9a1..4dee78a44 100644 --- a/src/transpiler.ts +++ b/src/transpiler.ts @@ -42,7 +42,6 @@ import { References, RejectPrefix, RejectUnsupportedFeatures, - ReplaceIdentifierContractMemberAccess, Require, ReturnInserter, ReturnVariableInitializer, From 6e0651d92fc145db7c2fa4f1360a44aedf6e1493 Mon Sep 17 00:00:00 2001 From: Carmen Cabrera Date: Mon, 20 Mar 2023 08:55:54 -0400 Subject: [PATCH 25/26] fix decorators style --- src/cairoWriter/writers/cairoFunctionDefinitionWriter.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/cairoWriter/writers/cairoFunctionDefinitionWriter.ts b/src/cairoWriter/writers/cairoFunctionDefinitionWriter.ts index 020b78ca4..08b3e0645 100644 --- a/src/cairoWriter/writers/cairoFunctionDefinitionWriter.ts +++ b/src/cairoWriter/writers/cairoFunctionDefinitionWriter.ts @@ -52,8 +52,8 @@ export class CairoFunctionDefinitionWriter extends CairoASTNodeWriter { if (node.kind === FunctionKind.Constructor) return ['#[constructor]']; const decorators: string[] = []; if (node.kind === FunctionKind.Fallback) { - decorators.push('@raw_input'); - if (node.vParameters.vParameters.length > 0) decorators.push('@raw_output'); + decorators.push('#[raw_input]'); + if (node.vParameters.vParameters.length > 0) decorators.push('#[raw_output]'); } if (node.visibility === FunctionVisibility.External) { 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 26/26] 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; }