// SPDX-License-Identifier: MIT

pragma solidity 0.8.19;

contract Halo2Verifier {
    fallback(bytes calldata) external returns (bytes memory) {
        assembly ("memory-safe") {
            // Enforce that Solidity memory layout is respected
            let data := mload(0x40)
            if iszero(eq(data, 0x80)) {
                revert(0, 0)
            }

            let success := true
            let f_p := 0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47
            let f_q := 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
            function validate_ec_point(x, y) -> valid {
                {
                    let x_lt_p := lt(x, 0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47)
                    let y_lt_p := lt(y, 0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47)
                    valid := and(x_lt_p, y_lt_p)
                }
                {
                    let y_square := mulmod(y, y, 0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47)
                    let x_square := mulmod(x, x, 0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47)
                    let x_cube := mulmod(x_square, x, 0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47)
                    let x_cube_plus_3 := addmod(x_cube, 3, 0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47)
                    let is_affine := eq(x_cube_plus_3, y_square)
                    valid := and(valid, is_affine)
                }
            }
            mstore(0xa0, mod(calldataload(0x0), f_q))
mstore(0xc0, mod(calldataload(0x20), f_q))
mstore(0xe0, mod(calldataload(0x40), f_q))
mstore(0x100, mod(calldataload(0x60), f_q))
mstore(0x120, mod(calldataload(0x80), f_q))
mstore(0x140, mod(calldataload(0xa0), f_q))
mstore(0x160, mod(calldataload(0xc0), f_q))
mstore(0x180, mod(calldataload(0xe0), f_q))
mstore(0x1a0, mod(calldataload(0x100), f_q))
mstore(0x1c0, mod(calldataload(0x120), f_q))
mstore(0x1e0, mod(calldataload(0x140), f_q))
mstore(0x200, mod(calldataload(0x160), f_q))
mstore(0x80, 4821513469282282135963313459762076388609226322911319502565905456075264100373)

        {
            let x := calldataload(0x180)
            mstore(0x220, x)
            let y := calldataload(0x1a0)
            mstore(0x240, y)
            success := and(validate_ec_point(x, y), success)
        }

        {
            let x := calldataload(0x1c0)
            mstore(0x260, x)
            let y := calldataload(0x1e0)
            mstore(0x280, y)
            success := and(validate_ec_point(x, y), success)
        }

        {
            let x := calldataload(0x200)
            mstore(0x2a0, x)
            let y := calldataload(0x220)
            mstore(0x2c0, y)
            success := and(validate_ec_point(x, y), success)
        }
mstore(0x2e0, keccak256(0x80, 608))
{
            let hash := mload(0x2e0)
            mstore(0x300, mod(hash, f_q))
            mstore(0x320, hash)
        }

        {
            let x := calldataload(0x240)
            mstore(0x340, x)
            let y := calldataload(0x260)
            mstore(0x360, y)
            success := and(validate_ec_point(x, y), success)
        }

        {
            let x := calldataload(0x280)
            mstore(0x380, x)
            let y := calldataload(0x2a0)
            mstore(0x3a0, y)
            success := and(validate_ec_point(x, y), success)
        }
mstore(0x3c0, keccak256(0x320, 160))
{
            let hash := mload(0x3c0)
            mstore(0x3e0, mod(hash, f_q))
            mstore(0x400, hash)
        }
mstore8(1056, 1)
mstore(0x420, keccak256(0x400, 33))
{
            let hash := mload(0x420)
            mstore(0x440, mod(hash, f_q))
            mstore(0x460, hash)
        }

        {
            let x := calldataload(0x2c0)
            mstore(0x480, x)
            let y := calldataload(0x2e0)
            mstore(0x4a0, y)
            success := and(validate_ec_point(x, y), success)
        }

        {
            let x := calldataload(0x300)
            mstore(0x4c0, x)
            let y := calldataload(0x320)
            mstore(0x4e0, y)
            success := and(validate_ec_point(x, y), success)
        }

        {
            let x := calldataload(0x340)
            mstore(0x500, x)
            let y := calldataload(0x360)
            mstore(0x520, y)
            success := and(validate_ec_point(x, y), success)
        }

        {
            let x := calldataload(0x380)
            mstore(0x540, x)
            let y := calldataload(0x3a0)
            mstore(0x560, y)
            success := and(validate_ec_point(x, y), success)
        }

        {
            let x := calldataload(0x3c0)
            mstore(0x580, x)
            let y := calldataload(0x3e0)
            mstore(0x5a0, y)
            success := and(validate_ec_point(x, y), success)
        }
mstore(0x5c0, keccak256(0x460, 352))
{
            let hash := mload(0x5c0)
            mstore(0x5e0, mod(hash, f_q))
            mstore(0x600, hash)
        }

        {
            let x := calldataload(0x400)
            mstore(0x620, x)
            let y := calldataload(0x420)
            mstore(0x640, y)
            success := and(validate_ec_point(x, y), success)
        }

        {
            let x := calldataload(0x440)
            mstore(0x660, x)
            let y := calldataload(0x460)
            mstore(0x680, y)
            success := and(validate_ec_point(x, y), success)
        }

        {
            let x := calldataload(0x480)
            mstore(0x6a0, x)
            let y := calldataload(0x4a0)
            mstore(0x6c0, y)
            success := and(validate_ec_point(x, y), success)
        }
mstore(0x6e0, keccak256(0x600, 224))
{
            let hash := mload(0x6e0)
            mstore(0x700, mod(hash, f_q))
            mstore(0x720, hash)
        }
mstore(0x740, mod(calldataload(0x4c0), f_q))
mstore(0x760, mod(calldataload(0x4e0), f_q))
mstore(0x780, mod(calldataload(0x500), f_q))
mstore(0x7a0, mod(calldataload(0x520), f_q))
mstore(0x7c0, mod(calldataload(0x540), f_q))
mstore(0x7e0, mod(calldataload(0x560), f_q))
mstore(0x800, mod(calldataload(0x580), f_q))
mstore(0x820, mod(calldataload(0x5a0), f_q))
mstore(0x840, mod(calldataload(0x5c0), f_q))
mstore(0x860, mod(calldataload(0x5e0), f_q))
mstore(0x880, mod(calldataload(0x600), f_q))
mstore(0x8a0, mod(calldataload(0x620), f_q))
mstore(0x8c0, mod(calldataload(0x640), f_q))
mstore(0x8e0, mod(calldataload(0x660), f_q))
mstore(0x900, mod(calldataload(0x680), f_q))
mstore(0x920, mod(calldataload(0x6a0), f_q))
mstore(0x940, mod(calldataload(0x6c0), f_q))
mstore(0x960, mod(calldataload(0x6e0), f_q))
mstore(0x980, mod(calldataload(0x700), f_q))
mstore(0x9a0, mod(calldataload(0x720), f_q))
mstore(0x9c0, mod(calldataload(0x740), f_q))
mstore(0x9e0, mod(calldataload(0x760), f_q))
mstore(0xa00, mod(calldataload(0x780), f_q))
mstore(0xa20, mod(calldataload(0x7a0), f_q))
mstore(0xa40, mod(calldataload(0x7c0), f_q))
mstore(0xa60, mod(calldataload(0x7e0), f_q))
mstore(0xa80, mod(calldataload(0x800), f_q))
mstore(0xaa0, mod(calldataload(0x820), f_q))
mstore(0xac0, mod(calldataload(0x840), f_q))
mstore(0xae0, mod(calldataload(0x860), f_q))
mstore(0xb00, mod(calldataload(0x880), f_q))
mstore(0xb20, mod(calldataload(0x8a0), f_q))
mstore(0xb40, keccak256(0x720, 1056))
{
            let hash := mload(0xb40)
            mstore(0xb60, mod(hash, f_q))
            mstore(0xb80, hash)
        }
mstore8(2976, 1)
mstore(0xba0, keccak256(0xb80, 33))
{
            let hash := mload(0xba0)
            mstore(0xbc0, mod(hash, f_q))
            mstore(0xbe0, hash)
        }

        {
            let x := calldataload(0x8c0)
            mstore(0xc00, x)
            let y := calldataload(0x8e0)
            mstore(0xc20, y)
            success := and(validate_ec_point(x, y), success)
        }
mstore(0xc40, keccak256(0xbe0, 96))
{
            let hash := mload(0xc40)
            mstore(0xc60, mod(hash, f_q))
            mstore(0xc80, hash)
        }

        {
            let x := calldataload(0x900)
            mstore(0xca0, x)
            let y := calldataload(0x920)
            mstore(0xcc0, y)
            success := and(validate_ec_point(x, y), success)
        }
{
            let x := mload(0xa0)
x := add(x, shl(88, mload(0xc0)))
x := add(x, shl(176, mload(0xe0)))
mstore(3296, x)
let y := mload(0x100)
y := add(y, shl(88, mload(0x120)))
y := add(y, shl(176, mload(0x140)))
mstore(3328, y)

            success := and(validate_ec_point(x, y), success)
        }
{
            let x := mload(0x160)
x := add(x, shl(88, mload(0x180)))
x := add(x, shl(176, mload(0x1a0)))
mstore(3360, x)
let y := mload(0x1c0)
y := add(y, shl(88, mload(0x1e0)))
y := add(y, shl(176, mload(0x200)))
mstore(3392, y)

            success := and(validate_ec_point(x, y), success)
        }
mstore(0xd60, mulmod(mload(0x700), mload(0x700), f_q))
mstore(0xd80, mulmod(mload(0xd60), mload(0xd60), f_q))
mstore(0xda0, mulmod(mload(0xd80), mload(0xd80), f_q))
mstore(0xdc0, mulmod(mload(0xda0), mload(0xda0), f_q))
mstore(0xde0, mulmod(mload(0xdc0), mload(0xdc0), f_q))
mstore(0xe00, mulmod(mload(0xde0), mload(0xde0), f_q))
mstore(0xe20, mulmod(mload(0xe00), mload(0xe00), f_q))
mstore(0xe40, mulmod(mload(0xe20), mload(0xe20), f_q))
mstore(0xe60, mulmod(mload(0xe40), mload(0xe40), f_q))
mstore(0xe80, mulmod(mload(0xe60), mload(0xe60), f_q))
mstore(0xea0, mulmod(mload(0xe80), mload(0xe80), f_q))
mstore(0xec0, mulmod(mload(0xea0), mload(0xea0), f_q))
mstore(0xee0, mulmod(mload(0xec0), mload(0xec0), f_q))
mstore(0xf00, mulmod(mload(0xee0), mload(0xee0), f_q))
mstore(0xf20, mulmod(mload(0xf00), mload(0xf00), f_q))
mstore(0xf40, mulmod(mload(0xf20), mload(0xf20), f_q))
mstore(0xf60, mulmod(mload(0xf40), mload(0xf40), f_q))
mstore(0xf80, mulmod(mload(0xf60), mload(0xf60), f_q))
mstore(0xfa0, mulmod(mload(0xf80), mload(0xf80), f_q))
mstore(0xfc0, mulmod(mload(0xfa0), mload(0xfa0), f_q))
mstore(0xfe0, mulmod(mload(0xfc0), mload(0xfc0), f_q))
mstore(0x1000, addmod(mload(0xfe0), 21888242871839275222246405745257275088548364400416034343698204186575808495616, f_q))
mstore(0x1020, mulmod(mload(0x1000), 21888232434711746154598842647110004286396165347431605739555851272621938401409, f_q))
mstore(0x1040, mulmod(mload(0x1020), 20975929243409798062839949658616274858986091382510192949221301676705706354487, f_q))
mstore(0x1060, addmod(mload(0x700), 912313628429477159406456086641000229562273017905841394476902509870102141130, f_q))
mstore(0x1080, mulmod(mload(0x1020), 495188420091111145957709789221178673495499187437761988132837836548330853701, f_q))
mstore(0x10a0, addmod(mload(0x700), 21393054451748164076288695956036096415052865212978272355565366350027477641916, f_q))
mstore(0x10c0, mulmod(mload(0x1020), 16064522944768515290584536219762686197737451920702130080538975732575755569557, f_q))
mstore(0x10e0, addmod(mload(0x700), 5823719927070759931661869525494588890810912479713904263159228454000052926060, f_q))
mstore(0x1100, mulmod(mload(0x1020), 14686510910986211321976396297238126901237973400949744736326777596334651355305, f_q))
mstore(0x1120, addmod(mload(0x700), 7201731960853063900270009448019148187310390999466289607371426590241157140312, f_q))
mstore(0x1140, mulmod(mload(0x1020), 10939663269433627367777756708678102241564365262857670666700619874077960926249, f_q))
mstore(0x1160, addmod(mload(0x700), 10948579602405647854468649036579172846983999137558363676997584312497847569368, f_q))
mstore(0x1180, mulmod(mload(0x1020), 15402826414547299628414612080036060696555554914079673875872749760617770134879, f_q))
mstore(0x11a0, addmod(mload(0x700), 6485416457291975593831793665221214391992809486336360467825454425958038360738, f_q))
mstore(0x11c0, mulmod(mload(0x1020), 2785514556381676080176937710880804108647911392478702105860685610379369825016, f_q))
mstore(0x11e0, addmod(mload(0x700), 19102728315457599142069468034376470979900453007937332237837518576196438670601, f_q))
mstore(0x1200, mulmod(mload(0x1020), 1, f_q))
mstore(0x1220, addmod(mload(0x700), 21888242871839275222246405745257275088548364400416034343698204186575808495616, f_q))
mstore(0x1240, mulmod(mload(0x1020), 1426404432721484388505361748317961535523355871255605456897797744433766488507, f_q))
mstore(0x1260, addmod(mload(0x700), 20461838439117790833741043996939313553025008529160428886800406442142042007110, f_q))
mstore(0x1280, mulmod(mload(0x1020), 19032961837237948602743626455740240236231119053033140765040043513661803148152, f_q))
mstore(0x12a0, addmod(mload(0x700), 2855281034601326619502779289517034852317245347382893578658160672914005347465, f_q))
mstore(0x12c0, mulmod(mload(0x1020), 3766081621734395783232337525162072736827576297943013392955872170138036189193, f_q))
mstore(0x12e0, addmod(mload(0x700), 18122161250104879439014068220095202351720788102473020950742332016437772306424, f_q))
mstore(0x1300, mulmod(mload(0x1020), 5854133144571823792863860130267644613802765696134002830362054821530146160770, f_q))
mstore(0x1320, addmod(mload(0x700), 16034109727267451429382545614989630474745598704282031513336149365045662334847, f_q))
mstore(0x1340, mulmod(mload(0x1020), 14557038802599140430182096396825290815503940951075961210638273254419942783582, f_q))
mstore(0x1360, addmod(mload(0x700), 7331204069240134792064309348431984273044423449340073133059930932155865712035, f_q))
mstore(0x1380, mulmod(mload(0x1020), 9697063347556872083384215826199993067635178715531258559890418744774301211662, f_q))
mstore(0x13a0, addmod(mload(0x700), 12191179524282403138862189919057282020913185684884775783807785441801507283955, f_q))
mstore(0x13c0, mulmod(mload(0x1020), 12459868075641381822485233712013080087763946065665469821362892189399541605692, f_q))
mstore(0x13e0, addmod(mload(0x700), 9428374796197893399761172033244195000784418334750564522335311997176266889925, f_q))
mstore(0x1400, mulmod(mload(0x1020), 6955697244493336113861667751840378876927906302623587437721024018233754910398, f_q))
mstore(0x1420, addmod(mload(0x700), 14932545627345939108384737993416896211620458097792446905977180168342053585219, f_q))
mstore(0x1440, mulmod(mload(0x1020), 20345677989844117909528750049476969581182118546166966482506114734614108237981, f_q))
mstore(0x1460, addmod(mload(0x700), 1542564881995157312717655695780305507366245854249067861192089451961700257636, f_q))
mstore(0x1480, mulmod(mload(0x1020), 5289443209903185443361862148540090689648485914368835830972895623576469023722, f_q))
mstore(0x14a0, addmod(mload(0x700), 16598799661936089778884543596717184398899878486047198512725308562999339471895, f_q))
mstore(0x14c0, mulmod(mload(0x1020), 557567375339945239933617516585967620814823575807691402619711360028043331811, f_q))
mstore(0x14e0, addmod(mload(0x700), 21330675496499329982312788228671307467733540824608342941078492826547765163806, f_q))
{
            let prod := mload(0x1060)

                prod := mulmod(mload(0x10a0), prod, f_q)
                mstore(0x1500, prod)
            
                prod := mulmod(mload(0x10e0), prod, f_q)
                mstore(0x1520, prod)
            
                prod := mulmod(mload(0x1120), prod, f_q)
                mstore(0x1540, prod)
            
                prod := mulmod(mload(0x1160), prod, f_q)
                mstore(0x1560, prod)
            
                prod := mulmod(mload(0x11a0), prod, f_q)
                mstore(0x1580, prod)
            
                prod := mulmod(mload(0x11e0), prod, f_q)
                mstore(0x15a0, prod)
            
                prod := mulmod(mload(0x1220), prod, f_q)
                mstore(0x15c0, prod)
            
                prod := mulmod(mload(0x1260), prod, f_q)
                mstore(0x15e0, prod)
            
                prod := mulmod(mload(0x12a0), prod, f_q)
                mstore(0x1600, prod)
            
                prod := mulmod(mload(0x12e0), prod, f_q)
                mstore(0x1620, prod)
            
                prod := mulmod(mload(0x1320), prod, f_q)
                mstore(0x1640, prod)
            
                prod := mulmod(mload(0x1360), prod, f_q)
                mstore(0x1660, prod)
            
                prod := mulmod(mload(0x13a0), prod, f_q)
                mstore(0x1680, prod)
            
                prod := mulmod(mload(0x13e0), prod, f_q)
                mstore(0x16a0, prod)
            
                prod := mulmod(mload(0x1420), prod, f_q)
                mstore(0x16c0, prod)
            
                prod := mulmod(mload(0x1460), prod, f_q)
                mstore(0x16e0, prod)
            
                prod := mulmod(mload(0x14a0), prod, f_q)
                mstore(0x1700, prod)
            
                prod := mulmod(mload(0x14e0), prod, f_q)
                mstore(0x1720, prod)
            
                prod := mulmod(mload(0x1000), prod, f_q)
                mstore(0x1740, prod)
            
        }
mstore(0x1780, 32)
mstore(0x17a0, 32)
mstore(0x17c0, 32)
mstore(0x17e0, mload(0x1740))
mstore(0x1800, 21888242871839275222246405745257275088548364400416034343698204186575808495615)
mstore(0x1820, 21888242871839275222246405745257275088548364400416034343698204186575808495617)
success := and(eq(staticcall(gas(), 0x5, 0x1780, 0xc0, 0x1760, 0x20), 1), success)
{
            
            let inv := mload(0x1760)
            let v
        
                    v := mload(0x1000)
                    mstore(4096, mulmod(mload(0x1720), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x14e0)
                    mstore(5344, mulmod(mload(0x1700), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x14a0)
                    mstore(5280, mulmod(mload(0x16e0), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x1460)
                    mstore(5216, mulmod(mload(0x16c0), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x1420)
                    mstore(5152, mulmod(mload(0x16a0), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x13e0)
                    mstore(5088, mulmod(mload(0x1680), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x13a0)
                    mstore(5024, mulmod(mload(0x1660), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x1360)
                    mstore(4960, mulmod(mload(0x1640), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x1320)
                    mstore(4896, mulmod(mload(0x1620), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x12e0)
                    mstore(4832, mulmod(mload(0x1600), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x12a0)
                    mstore(4768, mulmod(mload(0x15e0), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x1260)
                    mstore(4704, mulmod(mload(0x15c0), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x1220)
                    mstore(4640, mulmod(mload(0x15a0), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x11e0)
                    mstore(4576, mulmod(mload(0x1580), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x11a0)
                    mstore(4512, mulmod(mload(0x1560), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x1160)
                    mstore(4448, mulmod(mload(0x1540), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x1120)
                    mstore(4384, mulmod(mload(0x1520), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x10e0)
                    mstore(4320, mulmod(mload(0x1500), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x10a0)
                    mstore(4256, mulmod(mload(0x1060), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                mstore(0x1060, inv)

        }
mstore(0x1840, mulmod(mload(0x1040), mload(0x1060), f_q))
mstore(0x1860, mulmod(mload(0x1080), mload(0x10a0), f_q))
mstore(0x1880, mulmod(mload(0x10c0), mload(0x10e0), f_q))
mstore(0x18a0, mulmod(mload(0x1100), mload(0x1120), f_q))
mstore(0x18c0, mulmod(mload(0x1140), mload(0x1160), f_q))
mstore(0x18e0, mulmod(mload(0x1180), mload(0x11a0), f_q))
mstore(0x1900, mulmod(mload(0x11c0), mload(0x11e0), f_q))
mstore(0x1920, mulmod(mload(0x1200), mload(0x1220), f_q))
mstore(0x1940, mulmod(mload(0x1240), mload(0x1260), f_q))
mstore(0x1960, mulmod(mload(0x1280), mload(0x12a0), f_q))
mstore(0x1980, mulmod(mload(0x12c0), mload(0x12e0), f_q))
mstore(0x19a0, mulmod(mload(0x1300), mload(0x1320), f_q))
mstore(0x19c0, mulmod(mload(0x1340), mload(0x1360), f_q))
mstore(0x19e0, mulmod(mload(0x1380), mload(0x13a0), f_q))
mstore(0x1a00, mulmod(mload(0x13c0), mload(0x13e0), f_q))
mstore(0x1a20, mulmod(mload(0x1400), mload(0x1420), f_q))
mstore(0x1a40, mulmod(mload(0x1440), mload(0x1460), f_q))
mstore(0x1a60, mulmod(mload(0x1480), mload(0x14a0), f_q))
mstore(0x1a80, mulmod(mload(0x14c0), mload(0x14e0), f_q))
{
            let result := mulmod(mload(0x1920), mload(0xa0), f_q)
result := addmod(mulmod(mload(0x1940), mload(0xc0), f_q), result, f_q)
result := addmod(mulmod(mload(0x1960), mload(0xe0), f_q), result, f_q)
result := addmod(mulmod(mload(0x1980), mload(0x100), f_q), result, f_q)
result := addmod(mulmod(mload(0x19a0), mload(0x120), f_q), result, f_q)
result := addmod(mulmod(mload(0x19c0), mload(0x140), f_q), result, f_q)
result := addmod(mulmod(mload(0x19e0), mload(0x160), f_q), result, f_q)
result := addmod(mulmod(mload(0x1a00), mload(0x180), f_q), result, f_q)
result := addmod(mulmod(mload(0x1a20), mload(0x1a0), f_q), result, f_q)
result := addmod(mulmod(mload(0x1a40), mload(0x1c0), f_q), result, f_q)
result := addmod(mulmod(mload(0x1a60), mload(0x1e0), f_q), result, f_q)
result := addmod(mulmod(mload(0x1a80), mload(0x200), f_q), result, f_q)
mstore(6816, result)
        }
mstore(0x1ac0, mulmod(mload(0x780), mload(0x760), f_q))
mstore(0x1ae0, addmod(mload(0x740), mload(0x1ac0), f_q))
mstore(0x1b00, addmod(mload(0x1ae0), sub(f_q, mload(0x7a0)), f_q))
mstore(0x1b20, mulmod(mload(0x1b00), mload(0x8a0), f_q))
mstore(0x1b40, mulmod(mload(0x5e0), mload(0x1b20), f_q))
mstore(0x1b60, mulmod(mload(0x800), mload(0x7e0), f_q))
mstore(0x1b80, addmod(mload(0x7c0), mload(0x1b60), f_q))
mstore(0x1ba0, addmod(mload(0x1b80), sub(f_q, mload(0x820)), f_q))
mstore(0x1bc0, mulmod(mload(0x1ba0), mload(0x8c0), f_q))
mstore(0x1be0, addmod(mload(0x1b40), mload(0x1bc0), f_q))
mstore(0x1c00, mulmod(mload(0x5e0), mload(0x1be0), f_q))
mstore(0x1c20, addmod(1, sub(f_q, mload(0x9a0)), f_q))
mstore(0x1c40, mulmod(mload(0x1c20), mload(0x1920), f_q))
mstore(0x1c60, addmod(mload(0x1c00), mload(0x1c40), f_q))
mstore(0x1c80, mulmod(mload(0x5e0), mload(0x1c60), f_q))
mstore(0x1ca0, mulmod(mload(0xa60), mload(0xa60), f_q))
mstore(0x1cc0, addmod(mload(0x1ca0), sub(f_q, mload(0xa60)), f_q))
mstore(0x1ce0, mulmod(mload(0x1cc0), mload(0x1840), f_q))
mstore(0x1d00, addmod(mload(0x1c80), mload(0x1ce0), f_q))
mstore(0x1d20, mulmod(mload(0x5e0), mload(0x1d00), f_q))
mstore(0x1d40, addmod(mload(0xa00), sub(f_q, mload(0x9e0)), f_q))
mstore(0x1d60, mulmod(mload(0x1d40), mload(0x1920), f_q))
mstore(0x1d80, addmod(mload(0x1d20), mload(0x1d60), f_q))
mstore(0x1da0, mulmod(mload(0x5e0), mload(0x1d80), f_q))
mstore(0x1dc0, addmod(mload(0xa60), sub(f_q, mload(0xa40)), f_q))
mstore(0x1de0, mulmod(mload(0x1dc0), mload(0x1920), f_q))
mstore(0x1e00, addmod(mload(0x1da0), mload(0x1de0), f_q))
mstore(0x1e20, mulmod(mload(0x5e0), mload(0x1e00), f_q))
mstore(0x1e40, addmod(1, sub(f_q, mload(0x1840)), f_q))
mstore(0x1e60, addmod(mload(0x1860), mload(0x1880), f_q))
mstore(0x1e80, addmod(mload(0x1e60), mload(0x18a0), f_q))
mstore(0x1ea0, addmod(mload(0x1e80), mload(0x18c0), f_q))
mstore(0x1ec0, addmod(mload(0x1ea0), mload(0x18e0), f_q))
mstore(0x1ee0, addmod(mload(0x1ec0), mload(0x1900), f_q))
mstore(0x1f00, addmod(mload(0x1e40), sub(f_q, mload(0x1ee0)), f_q))
mstore(0x1f20, mulmod(mload(0x900), mload(0x3e0), f_q))
mstore(0x1f40, addmod(mload(0x860), mload(0x1f20), f_q))
mstore(0x1f60, addmod(mload(0x1f40), mload(0x440), f_q))
mstore(0x1f80, mulmod(mload(0x920), mload(0x3e0), f_q))
mstore(0x1fa0, addmod(mload(0x740), mload(0x1f80), f_q))
mstore(0x1fc0, addmod(mload(0x1fa0), mload(0x440), f_q))
mstore(0x1fe0, mulmod(mload(0x1fc0), mload(0x1f60), f_q))
mstore(0x2000, mulmod(mload(0x1fe0), mload(0x9c0), f_q))
mstore(0x2020, mulmod(1, mload(0x3e0), f_q))
mstore(0x2040, mulmod(mload(0x700), mload(0x2020), f_q))
mstore(0x2060, addmod(mload(0x860), mload(0x2040), f_q))
mstore(0x2080, addmod(mload(0x2060), mload(0x440), f_q))
mstore(0x20a0, mulmod(4131629893567559867359510883348571134090853742863529169391034518566172092834, mload(0x3e0), f_q))
mstore(0x20c0, mulmod(mload(0x700), mload(0x20a0), f_q))
mstore(0x20e0, addmod(mload(0x740), mload(0x20c0), f_q))
mstore(0x2100, addmod(mload(0x20e0), mload(0x440), f_q))
mstore(0x2120, mulmod(mload(0x2100), mload(0x2080), f_q))
mstore(0x2140, mulmod(mload(0x2120), mload(0x9a0), f_q))
mstore(0x2160, addmod(mload(0x2000), sub(f_q, mload(0x2140)), f_q))
mstore(0x2180, mulmod(mload(0x2160), mload(0x1f00), f_q))
mstore(0x21a0, addmod(mload(0x1e20), mload(0x2180), f_q))
mstore(0x21c0, mulmod(mload(0x5e0), mload(0x21a0), f_q))
mstore(0x21e0, mulmod(mload(0x940), mload(0x3e0), f_q))
mstore(0x2200, addmod(mload(0x7c0), mload(0x21e0), f_q))
mstore(0x2220, addmod(mload(0x2200), mload(0x440), f_q))
mstore(0x2240, mulmod(mload(0x960), mload(0x3e0), f_q))
mstore(0x2260, addmod(mload(0x840), mload(0x2240), f_q))
mstore(0x2280, addmod(mload(0x2260), mload(0x440), f_q))
mstore(0x22a0, mulmod(mload(0x2280), mload(0x2220), f_q))
mstore(0x22c0, mulmod(mload(0x22a0), mload(0xa20), f_q))
mstore(0x22e0, mulmod(8910878055287538404433155982483128285667088683464058436815641868457422632747, mload(0x3e0), f_q))
mstore(0x2300, mulmod(mload(0x700), mload(0x22e0), f_q))
mstore(0x2320, addmod(mload(0x7c0), mload(0x2300), f_q))
mstore(0x2340, addmod(mload(0x2320), mload(0x440), f_q))
mstore(0x2360, mulmod(11166246659983828508719468090013646171463329086121580628794302409516816350802, mload(0x3e0), f_q))
mstore(0x2380, mulmod(mload(0x700), mload(0x2360), f_q))
mstore(0x23a0, addmod(mload(0x840), mload(0x2380), f_q))
mstore(0x23c0, addmod(mload(0x23a0), mload(0x440), f_q))
mstore(0x23e0, mulmod(mload(0x23c0), mload(0x2340), f_q))
mstore(0x2400, mulmod(mload(0x23e0), mload(0xa00), f_q))
mstore(0x2420, addmod(mload(0x22c0), sub(f_q, mload(0x2400)), f_q))
mstore(0x2440, mulmod(mload(0x2420), mload(0x1f00), f_q))
mstore(0x2460, addmod(mload(0x21c0), mload(0x2440), f_q))
mstore(0x2480, mulmod(mload(0x5e0), mload(0x2460), f_q))
mstore(0x24a0, mulmod(mload(0x980), mload(0x3e0), f_q))
mstore(0x24c0, addmod(mload(0x1aa0), mload(0x24a0), f_q))
mstore(0x24e0, addmod(mload(0x24c0), mload(0x440), f_q))
mstore(0x2500, mulmod(mload(0x24e0), mload(0xa80), f_q))
mstore(0x2520, mulmod(284840088355319032285349970403338060113257071685626700086398481893096618818, mload(0x3e0), f_q))
mstore(0x2540, mulmod(mload(0x700), mload(0x2520), f_q))
mstore(0x2560, addmod(mload(0x1aa0), mload(0x2540), f_q))
mstore(0x2580, addmod(mload(0x2560), mload(0x440), f_q))
mstore(0x25a0, mulmod(mload(0x2580), mload(0xa60), f_q))
mstore(0x25c0, addmod(mload(0x2500), sub(f_q, mload(0x25a0)), f_q))
mstore(0x25e0, mulmod(mload(0x25c0), mload(0x1f00), f_q))
mstore(0x2600, addmod(mload(0x2480), mload(0x25e0), f_q))
mstore(0x2620, mulmod(mload(0x5e0), mload(0x2600), f_q))
mstore(0x2640, addmod(1, sub(f_q, mload(0xaa0)), f_q))
mstore(0x2660, mulmod(mload(0x2640), mload(0x1920), f_q))
mstore(0x2680, addmod(mload(0x2620), mload(0x2660), f_q))
mstore(0x26a0, mulmod(mload(0x5e0), mload(0x2680), f_q))
mstore(0x26c0, mulmod(mload(0xaa0), mload(0xaa0), f_q))
mstore(0x26e0, addmod(mload(0x26c0), sub(f_q, mload(0xaa0)), f_q))
mstore(0x2700, mulmod(mload(0x26e0), mload(0x1840), f_q))
mstore(0x2720, addmod(mload(0x26a0), mload(0x2700), f_q))
mstore(0x2740, mulmod(mload(0x5e0), mload(0x2720), f_q))
mstore(0x2760, addmod(mload(0xae0), mload(0x3e0), f_q))
mstore(0x2780, mulmod(mload(0x2760), mload(0xac0), f_q))
mstore(0x27a0, addmod(mload(0xb20), mload(0x440), f_q))
mstore(0x27c0, mulmod(mload(0x27a0), mload(0x2780), f_q))
mstore(0x27e0, addmod(mload(0x840), mload(0x3e0), f_q))
mstore(0x2800, mulmod(mload(0x27e0), mload(0xaa0), f_q))
mstore(0x2820, addmod(mload(0x880), mload(0x440), f_q))
mstore(0x2840, mulmod(mload(0x2820), mload(0x2800), f_q))
mstore(0x2860, addmod(mload(0x27c0), sub(f_q, mload(0x2840)), f_q))
mstore(0x2880, mulmod(mload(0x2860), mload(0x1f00), f_q))
mstore(0x28a0, addmod(mload(0x2740), mload(0x2880), f_q))
mstore(0x28c0, mulmod(mload(0x5e0), mload(0x28a0), f_q))
mstore(0x28e0, addmod(mload(0xae0), sub(f_q, mload(0xb20)), f_q))
mstore(0x2900, mulmod(mload(0x28e0), mload(0x1920), f_q))
mstore(0x2920, addmod(mload(0x28c0), mload(0x2900), f_q))
mstore(0x2940, mulmod(mload(0x5e0), mload(0x2920), f_q))
mstore(0x2960, mulmod(mload(0x28e0), mload(0x1f00), f_q))
mstore(0x2980, addmod(mload(0xae0), sub(f_q, mload(0xb00)), f_q))
mstore(0x29a0, mulmod(mload(0x2980), mload(0x2960), f_q))
mstore(0x29c0, addmod(mload(0x2940), mload(0x29a0), f_q))
mstore(0x29e0, mulmod(mload(0xfe0), mload(0xfe0), f_q))
mstore(0x2a00, mulmod(mload(0x29e0), mload(0xfe0), f_q))
mstore(0x2a20, mulmod(1, mload(0xfe0), f_q))
mstore(0x2a40, mulmod(1, mload(0x29e0), f_q))
mstore(0x2a60, mulmod(mload(0x29c0), mload(0x1000), f_q))
mstore(0x2a80, mulmod(mload(0xd60), mload(0x700), f_q))
mstore(0x2aa0, mulmod(mload(0x2a80), mload(0x700), f_q))
mstore(0x2ac0, mulmod(mload(0x700), 20975929243409798062839949658616274858986091382510192949221301676705706354487, f_q))
mstore(0x2ae0, addmod(mload(0xc60), sub(f_q, mload(0x2ac0)), f_q))
mstore(0x2b00, mulmod(mload(0x700), 2785514556381676080176937710880804108647911392478702105860685610379369825016, f_q))
mstore(0x2b20, addmod(mload(0xc60), sub(f_q, mload(0x2b00)), f_q))
mstore(0x2b40, mulmod(mload(0x700), 1, f_q))
mstore(0x2b60, addmod(mload(0xc60), sub(f_q, mload(0x2b40)), f_q))
mstore(0x2b80, mulmod(mload(0x700), 1426404432721484388505361748317961535523355871255605456897797744433766488507, f_q))
mstore(0x2ba0, addmod(mload(0xc60), sub(f_q, mload(0x2b80)), f_q))
mstore(0x2bc0, mulmod(mload(0x700), 19032961837237948602743626455740240236231119053033140765040043513661803148152, f_q))
mstore(0x2be0, addmod(mload(0xc60), sub(f_q, mload(0x2bc0)), f_q))
mstore(0x2c00, mulmod(mload(0x700), 3766081621734395783232337525162072736827576297943013392955872170138036189193, f_q))
mstore(0x2c20, addmod(mload(0xc60), sub(f_q, mload(0x2c00)), f_q))
mstore(0x2c40, mulmod(12142985201493934370659158242092015678465417407805993602870272259656026591649, mload(0x2a80), f_q))
mstore(0x2c60, mulmod(mload(0x2c40), 1, f_q))
{
            let result := mulmod(mload(0xc60), mload(0x2c40), f_q)
result := addmod(mulmod(mload(0x700), sub(f_q, mload(0x2c60)), f_q), result, f_q)
mstore(11392, result)
        }
mstore(0x2ca0, mulmod(12858672892267984631233883117647866851148059157064290846881981435700301865966, mload(0x2a80), f_q))
mstore(0x2cc0, mulmod(mload(0x2ca0), 1426404432721484388505361748317961535523355871255605456897797744433766488507, f_q))
{
            let result := mulmod(mload(0xc60), mload(0x2ca0), f_q)
result := addmod(mulmod(mload(0x700), sub(f_q, mload(0x2cc0)), f_q), result, f_q)
mstore(11488, result)
        }
mstore(0x2d00, mulmod(20880316823902385764034220950270964645276820671488089374347912013802613180902, mload(0x2a80), f_q))
mstore(0x2d20, mulmod(mload(0x2d00), 19032961837237948602743626455740240236231119053033140765040043513661803148152, f_q))
{
            let result := mulmod(mload(0xc60), mload(0x2d00), f_q)
result := addmod(mulmod(mload(0x700), sub(f_q, mload(0x2d20)), f_q), result, f_q)
mstore(11584, result)
        }
mstore(0x2d60, mulmod(17575202995145968412995467587554373308969396527144859871466654432792864477050, mload(0x2a80), f_q))
mstore(0x2d80, mulmod(mload(0x2d60), 3766081621734395783232337525162072736827576297943013392955872170138036189193, f_q))
{
            let result := mulmod(mload(0xc60), mload(0x2d60), f_q)
result := addmod(mulmod(mload(0x700), sub(f_q, mload(0x2d80)), f_q), result, f_q)
mstore(11680, result)
        }
mstore(0x2dc0, mulmod(1, mload(0x2b60), f_q))
mstore(0x2de0, mulmod(mload(0x2dc0), mload(0x2ba0), f_q))
mstore(0x2e00, mulmod(mload(0x2de0), mload(0x2be0), f_q))
mstore(0x2e20, mulmod(mload(0x2e00), mload(0x2c20), f_q))
{
            let result := mulmod(mload(0xc60), 1, f_q)
result := addmod(mulmod(mload(0x700), 21888242871839275222246405745257275088548364400416034343698204186575808495616, f_q), result, f_q)
mstore(11840, result)
        }
mstore(0x2e60, mulmod(21869340487638379139105209872801492456082780734504032269410146788560475001942, mload(0xd60), f_q))
mstore(0x2e80, mulmod(mload(0x2e60), 1, f_q))
{
            let result := mulmod(mload(0xc60), mload(0x2e60), f_q)
result := addmod(mulmod(mload(0x700), sub(f_q, mload(0x2e80)), f_q), result, f_q)
mstore(11936, result)
        }
mstore(0x2ec0, mulmod(16199055355995875908874098831560099797649990976433931925532505422809603664814, mload(0xd60), f_q))
mstore(0x2ee0, mulmod(mload(0x2ec0), 1426404432721484388505361748317961535523355871255605456897797744433766488507, f_q))
{
            let result := mulmod(mload(0xc60), mload(0x2ec0), f_q)
result := addmod(mulmod(mload(0x700), sub(f_q, mload(0x2ee0)), f_q), result, f_q)
mstore(12032, result)
        }
mstore(0x2f20, mulmod(4865187280763976036134135047793386535665014353502380106898040096680231678680, mload(0xd60), f_q))
mstore(0x2f40, mulmod(mload(0x2f20), 20975929243409798062839949658616274858986091382510192949221301676705706354487, f_q))
{
            let result := mulmod(mload(0xc60), mload(0x2f20), f_q)
result := addmod(mulmod(mload(0x700), sub(f_q, mload(0x2f40)), f_q), result, f_q)
mstore(12128, result)
        }
mstore(0x2f80, mulmod(mload(0x2de0), mload(0x2ae0), f_q))
mstore(0x2fa0, mulmod(20461838439117790833741043996939313553025008529160428886800406442142042007111, mload(0x700), f_q))
mstore(0x2fc0, mulmod(mload(0x2fa0), 1, f_q))
{
            let result := mulmod(mload(0xc60), mload(0x2fa0), f_q)
result := addmod(mulmod(mload(0x700), sub(f_q, mload(0x2fc0)), f_q), result, f_q)
mstore(12256, result)
        }
mstore(0x3000, mulmod(1426404432721484388505361748317961535523355871255605456897797744433766488506, mload(0x700), f_q))
mstore(0x3020, mulmod(mload(0x3000), 1426404432721484388505361748317961535523355871255605456897797744433766488507, f_q))
{
            let result := mulmod(mload(0xc60), mload(0x3000), f_q)
result := addmod(mulmod(mload(0x700), sub(f_q, mload(0x3020)), f_q), result, f_q)
mstore(12352, result)
        }
mstore(0x3060, mulmod(19102728315457599142069468034376470979900453007937332237837518576196438670602, mload(0x700), f_q))
mstore(0x3080, mulmod(mload(0x3060), 1, f_q))
{
            let result := mulmod(mload(0xc60), mload(0x3060), f_q)
result := addmod(mulmod(mload(0x700), sub(f_q, mload(0x3080)), f_q), result, f_q)
mstore(12448, result)
        }
mstore(0x30c0, mulmod(2785514556381676080176937710880804108647911392478702105860685610379369825015, mload(0x700), f_q))
mstore(0x30e0, mulmod(mload(0x30c0), 2785514556381676080176937710880804108647911392478702105860685610379369825016, f_q))
{
            let result := mulmod(mload(0xc60), mload(0x30c0), f_q)
result := addmod(mulmod(mload(0x700), sub(f_q, mload(0x30e0)), f_q), result, f_q)
mstore(12544, result)
        }
mstore(0x3120, mulmod(mload(0x2dc0), mload(0x2b20), f_q))
{
            let prod := mload(0x2c80)

                prod := mulmod(mload(0x2ce0), prod, f_q)
                mstore(0x3140, prod)
            
                prod := mulmod(mload(0x2d40), prod, f_q)
                mstore(0x3160, prod)
            
                prod := mulmod(mload(0x2da0), prod, f_q)
                mstore(0x3180, prod)
            
                prod := mulmod(mload(0x2e40), prod, f_q)
                mstore(0x31a0, prod)
            
                prod := mulmod(mload(0x2dc0), prod, f_q)
                mstore(0x31c0, prod)
            
                prod := mulmod(mload(0x2ea0), prod, f_q)
                mstore(0x31e0, prod)
            
                prod := mulmod(mload(0x2f00), prod, f_q)
                mstore(0x3200, prod)
            
                prod := mulmod(mload(0x2f60), prod, f_q)
                mstore(0x3220, prod)
            
                prod := mulmod(mload(0x2f80), prod, f_q)
                mstore(0x3240, prod)
            
                prod := mulmod(mload(0x2fe0), prod, f_q)
                mstore(0x3260, prod)
            
                prod := mulmod(mload(0x3040), prod, f_q)
                mstore(0x3280, prod)
            
                prod := mulmod(mload(0x2de0), prod, f_q)
                mstore(0x32a0, prod)
            
                prod := mulmod(mload(0x30a0), prod, f_q)
                mstore(0x32c0, prod)
            
                prod := mulmod(mload(0x3100), prod, f_q)
                mstore(0x32e0, prod)
            
                prod := mulmod(mload(0x3120), prod, f_q)
                mstore(0x3300, prod)
            
        }
mstore(0x3340, 32)
mstore(0x3360, 32)
mstore(0x3380, 32)
mstore(0x33a0, mload(0x3300))
mstore(0x33c0, 21888242871839275222246405745257275088548364400416034343698204186575808495615)
mstore(0x33e0, 21888242871839275222246405745257275088548364400416034343698204186575808495617)
success := and(eq(staticcall(gas(), 0x5, 0x3340, 0xc0, 0x3320, 0x20), 1), success)
{
            
            let inv := mload(0x3320)
            let v
        
                    v := mload(0x3120)
                    mstore(12576, mulmod(mload(0x32e0), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x3100)
                    mstore(12544, mulmod(mload(0x32c0), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x30a0)
                    mstore(12448, mulmod(mload(0x32a0), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x2de0)
                    mstore(11744, mulmod(mload(0x3280), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x3040)
                    mstore(12352, mulmod(mload(0x3260), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x2fe0)
                    mstore(12256, mulmod(mload(0x3240), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x2f80)
                    mstore(12160, mulmod(mload(0x3220), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x2f60)
                    mstore(12128, mulmod(mload(0x3200), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x2f00)
                    mstore(12032, mulmod(mload(0x31e0), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x2ea0)
                    mstore(11936, mulmod(mload(0x31c0), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x2dc0)
                    mstore(11712, mulmod(mload(0x31a0), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x2e40)
                    mstore(11840, mulmod(mload(0x3180), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x2da0)
                    mstore(11680, mulmod(mload(0x3160), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x2d40)
                    mstore(11584, mulmod(mload(0x3140), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x2ce0)
                    mstore(11488, mulmod(mload(0x2c80), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                mstore(0x2c80, inv)

        }
{
            let result := mload(0x2c80)
result := addmod(mload(0x2ce0), result, f_q)
result := addmod(mload(0x2d40), result, f_q)
result := addmod(mload(0x2da0), result, f_q)
mstore(13312, result)
        }
mstore(0x3420, mulmod(mload(0x2e20), mload(0x2dc0), f_q))
{
            let result := mload(0x2e40)
mstore(13376, result)
        }
mstore(0x3460, mulmod(mload(0x2e20), mload(0x2f80), f_q))
{
            let result := mload(0x2ea0)
result := addmod(mload(0x2f00), result, f_q)
result := addmod(mload(0x2f60), result, f_q)
mstore(13440, result)
        }
mstore(0x34a0, mulmod(mload(0x2e20), mload(0x2de0), f_q))
{
            let result := mload(0x2fe0)
result := addmod(mload(0x3040), result, f_q)
mstore(13504, result)
        }
mstore(0x34e0, mulmod(mload(0x2e20), mload(0x3120), f_q))
{
            let result := mload(0x30a0)
result := addmod(mload(0x3100), result, f_q)
mstore(13568, result)
        }
{
            let prod := mload(0x3400)

                prod := mulmod(mload(0x3440), prod, f_q)
                mstore(0x3520, prod)
            
                prod := mulmod(mload(0x3480), prod, f_q)
                mstore(0x3540, prod)
            
                prod := mulmod(mload(0x34c0), prod, f_q)
                mstore(0x3560, prod)
            
                prod := mulmod(mload(0x3500), prod, f_q)
                mstore(0x3580, prod)
            
        }
mstore(0x35c0, 32)
mstore(0x35e0, 32)
mstore(0x3600, 32)
mstore(0x3620, mload(0x3580))
mstore(0x3640, 21888242871839275222246405745257275088548364400416034343698204186575808495615)
mstore(0x3660, 21888242871839275222246405745257275088548364400416034343698204186575808495617)
success := and(eq(staticcall(gas(), 0x5, 0x35c0, 0xc0, 0x35a0, 0x20), 1), success)
{
            
            let inv := mload(0x35a0)
            let v
        
                    v := mload(0x3500)
                    mstore(13568, mulmod(mload(0x3560), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x34c0)
                    mstore(13504, mulmod(mload(0x3540), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x3480)
                    mstore(13440, mulmod(mload(0x3520), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                
                    v := mload(0x3440)
                    mstore(13376, mulmod(mload(0x3400), inv, f_q))
                    inv := mulmod(v, inv, f_q)
                mstore(0x3400, inv)

        }
mstore(0x3680, mulmod(mload(0x3420), mload(0x3440), f_q))
mstore(0x36a0, mulmod(mload(0x3460), mload(0x3480), f_q))
mstore(0x36c0, mulmod(mload(0x34a0), mload(0x34c0), f_q))
mstore(0x36e0, mulmod(mload(0x34e0), mload(0x3500), f_q))
mstore(0x3700, mulmod(mload(0xb60), mload(0xb60), f_q))
mstore(0x3720, mulmod(mload(0x3700), mload(0xb60), f_q))
mstore(0x3740, mulmod(mload(0x3720), mload(0xb60), f_q))
mstore(0x3760, mulmod(mload(0x3740), mload(0xb60), f_q))
mstore(0x3780, mulmod(mload(0x3760), mload(0xb60), f_q))
mstore(0x37a0, mulmod(mload(0x3780), mload(0xb60), f_q))
mstore(0x37c0, mulmod(mload(0x37a0), mload(0xb60), f_q))
mstore(0x37e0, mulmod(mload(0x37c0), mload(0xb60), f_q))
mstore(0x3800, mulmod(mload(0x37e0), mload(0xb60), f_q))
mstore(0x3820, mulmod(mload(0x3800), mload(0xb60), f_q))
mstore(0x3840, mulmod(mload(0x3820), mload(0xb60), f_q))
mstore(0x3860, mulmod(mload(0x3840), mload(0xb60), f_q))
mstore(0x3880, mulmod(mload(0xbc0), mload(0xbc0), f_q))
mstore(0x38a0, mulmod(mload(0x3880), mload(0xbc0), f_q))
mstore(0x38c0, mulmod(mload(0x38a0), mload(0xbc0), f_q))
mstore(0x38e0, mulmod(mload(0x38c0), mload(0xbc0), f_q))
{
            let result := mulmod(mload(0x740), mload(0x2c80), f_q)
result := addmod(mulmod(mload(0x760), mload(0x2ce0), f_q), result, f_q)
result := addmod(mulmod(mload(0x780), mload(0x2d40), f_q), result, f_q)
result := addmod(mulmod(mload(0x7a0), mload(0x2da0), f_q), result, f_q)
mstore(14592, result)
        }
mstore(0x3920, mulmod(mload(0x3900), mload(0x3400), f_q))
mstore(0x3940, mulmod(sub(f_q, mload(0x3920)), 1, f_q))
{
            let result := mulmod(mload(0x7c0), mload(0x2c80), f_q)
result := addmod(mulmod(mload(0x7e0), mload(0x2ce0), f_q), result, f_q)
result := addmod(mulmod(mload(0x800), mload(0x2d40), f_q), result, f_q)
result := addmod(mulmod(mload(0x820), mload(0x2da0), f_q), result, f_q)
mstore(14688, result)
        }
mstore(0x3980, mulmod(mload(0x3960), mload(0x3400), f_q))
mstore(0x39a0, mulmod(sub(f_q, mload(0x3980)), mload(0xb60), f_q))
mstore(0x39c0, mulmod(1, mload(0xb60), f_q))
mstore(0x39e0, addmod(mload(0x3940), mload(0x39a0), f_q))
mstore(0x3a00, mulmod(mload(0x39e0), 1, f_q))
mstore(0x3a20, mulmod(mload(0x39c0), 1, f_q))
mstore(0x3a40, mulmod(1, mload(0x3420), f_q))
{
            let result := mulmod(mload(0x840), mload(0x2e40), f_q)
mstore(14944, result)
        }
mstore(0x3a80, mulmod(mload(0x3a60), mload(0x3680), f_q))
mstore(0x3aa0, mulmod(sub(f_q, mload(0x3a80)), 1, f_q))
mstore(0x3ac0, mulmod(mload(0x3a40), 1, f_q))
{
            let result := mulmod(mload(0xb20), mload(0x2e40), f_q)
mstore(15072, result)
        }
mstore(0x3b00, mulmod(mload(0x3ae0), mload(0x3680), f_q))
mstore(0x3b20, mulmod(sub(f_q, mload(0x3b00)), mload(0xb60), f_q))
mstore(0x3b40, mulmod(mload(0x3a40), mload(0xb60), f_q))
mstore(0x3b60, addmod(mload(0x3aa0), mload(0x3b20), f_q))
{
            let result := mulmod(mload(0x860), mload(0x2e40), f_q)
mstore(15232, result)
        }
mstore(0x3ba0, mulmod(mload(0x3b80), mload(0x3680), f_q))
mstore(0x3bc0, mulmod(sub(f_q, mload(0x3ba0)), mload(0x3700), f_q))
mstore(0x3be0, mulmod(mload(0x3a40), mload(0x3700), f_q))
mstore(0x3c00, addmod(mload(0x3b60), mload(0x3bc0), f_q))
{
            let result := mulmod(mload(0x880), mload(0x2e40), f_q)
mstore(15392, result)
        }
mstore(0x3c40, mulmod(mload(0x3c20), mload(0x3680), f_q))
mstore(0x3c60, mulmod(sub(f_q, mload(0x3c40)), mload(0x3720), f_q))
mstore(0x3c80, mulmod(mload(0x3a40), mload(0x3720), f_q))
mstore(0x3ca0, addmod(mload(0x3c00), mload(0x3c60), f_q))
{
            let result := mulmod(mload(0x8a0), mload(0x2e40), f_q)
mstore(15552, result)
        }
mstore(0x3ce0, mulmod(mload(0x3cc0), mload(0x3680), f_q))
mstore(0x3d00, mulmod(sub(f_q, mload(0x3ce0)), mload(0x3740), f_q))
mstore(0x3d20, mulmod(mload(0x3a40), mload(0x3740), f_q))
mstore(0x3d40, addmod(mload(0x3ca0), mload(0x3d00), f_q))
{
            let result := mulmod(mload(0x8c0), mload(0x2e40), f_q)
mstore(15712, result)
        }
mstore(0x3d80, mulmod(mload(0x3d60), mload(0x3680), f_q))
mstore(0x3da0, mulmod(sub(f_q, mload(0x3d80)), mload(0x3760), f_q))
mstore(0x3dc0, mulmod(mload(0x3a40), mload(0x3760), f_q))
mstore(0x3de0, addmod(mload(0x3d40), mload(0x3da0), f_q))
{
            let result := mulmod(mload(0x900), mload(0x2e40), f_q)
mstore(15872, result)
        }
mstore(0x3e20, mulmod(mload(0x3e00), mload(0x3680), f_q))
mstore(0x3e40, mulmod(sub(f_q, mload(0x3e20)), mload(0x3780), f_q))
mstore(0x3e60, mulmod(mload(0x3a40), mload(0x3780), f_q))
mstore(0x3e80, addmod(mload(0x3de0), mload(0x3e40), f_q))
{
            let result := mulmod(mload(0x920), mload(0x2e40), f_q)
mstore(16032, result)
        }
mstore(0x3ec0, mulmod(mload(0x3ea0), mload(0x3680), f_q))
mstore(0x3ee0, mulmod(sub(f_q, mload(0x3ec0)), mload(0x37a0), f_q))
mstore(0x3f00, mulmod(mload(0x3a40), mload(0x37a0), f_q))
mstore(0x3f20, addmod(mload(0x3e80), mload(0x3ee0), f_q))
{
            let result := mulmod(mload(0x940), mload(0x2e40), f_q)
mstore(16192, result)
        }
mstore(0x3f60, mulmod(mload(0x3f40), mload(0x3680), f_q))
mstore(0x3f80, mulmod(sub(f_q, mload(0x3f60)), mload(0x37c0), f_q))
mstore(0x3fa0, mulmod(mload(0x3a40), mload(0x37c0), f_q))
mstore(0x3fc0, addmod(mload(0x3f20), mload(0x3f80), f_q))
{
            let result := mulmod(mload(0x960), mload(0x2e40), f_q)
mstore(16352, result)
        }
mstore(0x4000, mulmod(mload(0x3fe0), mload(0x3680), f_q))
mstore(0x4020, mulmod(sub(f_q, mload(0x4000)), mload(0x37e0), f_q))
mstore(0x4040, mulmod(mload(0x3a40), mload(0x37e0), f_q))
mstore(0x4060, addmod(mload(0x3fc0), mload(0x4020), f_q))
{
            let result := mulmod(mload(0x980), mload(0x2e40), f_q)
mstore(16512, result)
        }
mstore(0x40a0, mulmod(mload(0x4080), mload(0x3680), f_q))
mstore(0x40c0, mulmod(sub(f_q, mload(0x40a0)), mload(0x3800), f_q))
mstore(0x40e0, mulmod(mload(0x3a40), mload(0x3800), f_q))
mstore(0x4100, addmod(mload(0x4060), mload(0x40c0), f_q))
mstore(0x4120, mulmod(mload(0x2a20), mload(0x3420), f_q))
mstore(0x4140, mulmod(mload(0x2a40), mload(0x3420), f_q))
{
            let result := mulmod(mload(0x2a60), mload(0x2e40), f_q)
mstore(16736, result)
        }
mstore(0x4180, mulmod(mload(0x4160), mload(0x3680), f_q))
mstore(0x41a0, mulmod(sub(f_q, mload(0x4180)), mload(0x3820), f_q))
mstore(0x41c0, mulmod(mload(0x3a40), mload(0x3820), f_q))
mstore(0x41e0, mulmod(mload(0x4120), mload(0x3820), f_q))
mstore(0x4200, mulmod(mload(0x4140), mload(0x3820), f_q))
mstore(0x4220, addmod(mload(0x4100), mload(0x41a0), f_q))
{
            let result := mulmod(mload(0x8e0), mload(0x2e40), f_q)
mstore(16960, result)
        }
mstore(0x4260, mulmod(mload(0x4240), mload(0x3680), f_q))
mstore(0x4280, mulmod(sub(f_q, mload(0x4260)), mload(0x3840), f_q))
mstore(0x42a0, mulmod(mload(0x3a40), mload(0x3840), f_q))
mstore(0x42c0, addmod(mload(0x4220), mload(0x4280), f_q))
mstore(0x42e0, mulmod(mload(0x42c0), mload(0xbc0), f_q))
mstore(0x4300, mulmod(mload(0x3ac0), mload(0xbc0), f_q))
mstore(0x4320, mulmod(mload(0x3b40), mload(0xbc0), f_q))
mstore(0x4340, mulmod(mload(0x3be0), mload(0xbc0), f_q))
mstore(0x4360, mulmod(mload(0x3c80), mload(0xbc0), f_q))
mstore(0x4380, mulmod(mload(0x3d20), mload(0xbc0), f_q))
mstore(0x43a0, mulmod(mload(0x3dc0), mload(0xbc0), f_q))
mstore(0x43c0, mulmod(mload(0x3e60), mload(0xbc0), f_q))
mstore(0x43e0, mulmod(mload(0x3f00), mload(0xbc0), f_q))
mstore(0x4400, mulmod(mload(0x3fa0), mload(0xbc0), f_q))
mstore(0x4420, mulmod(mload(0x4040), mload(0xbc0), f_q))
mstore(0x4440, mulmod(mload(0x40e0), mload(0xbc0), f_q))
mstore(0x4460, mulmod(mload(0x41c0), mload(0xbc0), f_q))
mstore(0x4480, mulmod(mload(0x41e0), mload(0xbc0), f_q))
mstore(0x44a0, mulmod(mload(0x4200), mload(0xbc0), f_q))
mstore(0x44c0, mulmod(mload(0x42a0), mload(0xbc0), f_q))
mstore(0x44e0, addmod(mload(0x3a00), mload(0x42e0), f_q))
mstore(0x4500, mulmod(1, mload(0x3460), f_q))
{
            let result := mulmod(mload(0x9a0), mload(0x2ea0), f_q)
result := addmod(mulmod(mload(0x9c0), mload(0x2f00), f_q), result, f_q)
result := addmod(mulmod(mload(0x9e0), mload(0x2f60), f_q), result, f_q)
mstore(17696, result)
        }
mstore(0x4540, mulmod(mload(0x4520), mload(0x36a0), f_q))
mstore(0x4560, mulmod(sub(f_q, mload(0x4540)), 1, f_q))
mstore(0x4580, mulmod(mload(0x4500), 1, f_q))
{
            let result := mulmod(mload(0xa00), mload(0x2ea0), f_q)
result := addmod(mulmod(mload(0xa20), mload(0x2f00), f_q), result, f_q)
result := addmod(mulmod(mload(0xa40), mload(0x2f60), f_q), result, f_q)
mstore(17824, result)
        }
mstore(0x45c0, mulmod(mload(0x45a0), mload(0x36a0), f_q))
mstore(0x45e0, mulmod(sub(f_q, mload(0x45c0)), mload(0xb60), f_q))
mstore(0x4600, mulmod(mload(0x4500), mload(0xb60), f_q))
mstore(0x4620, addmod(mload(0x4560), mload(0x45e0), f_q))
mstore(0x4640, mulmod(mload(0x4620), mload(0x3880), f_q))
mstore(0x4660, mulmod(mload(0x4580), mload(0x3880), f_q))
mstore(0x4680, mulmod(mload(0x4600), mload(0x3880), f_q))
mstore(0x46a0, addmod(mload(0x44e0), mload(0x4640), f_q))
mstore(0x46c0, mulmod(1, mload(0x34a0), f_q))
{
            let result := mulmod(mload(0xa60), mload(0x2fe0), f_q)
result := addmod(mulmod(mload(0xa80), mload(0x3040), f_q), result, f_q)
mstore(18144, result)
        }
mstore(0x4700, mulmod(mload(0x46e0), mload(0x36c0), f_q))
mstore(0x4720, mulmod(sub(f_q, mload(0x4700)), 1, f_q))
mstore(0x4740, mulmod(mload(0x46c0), 1, f_q))
{
            let result := mulmod(mload(0xaa0), mload(0x2fe0), f_q)
result := addmod(mulmod(mload(0xac0), mload(0x3040), f_q), result, f_q)
mstore(18272, result)
        }
mstore(0x4780, mulmod(mload(0x4760), mload(0x36c0), f_q))
mstore(0x47a0, mulmod(sub(f_q, mload(0x4780)), mload(0xb60), f_q))
mstore(0x47c0, mulmod(mload(0x46c0), mload(0xb60), f_q))
mstore(0x47e0, addmod(mload(0x4720), mload(0x47a0), f_q))
mstore(0x4800, mulmod(mload(0x47e0), mload(0x38a0), f_q))
mstore(0x4820, mulmod(mload(0x4740), mload(0x38a0), f_q))
mstore(0x4840, mulmod(mload(0x47c0), mload(0x38a0), f_q))
mstore(0x4860, addmod(mload(0x46a0), mload(0x4800), f_q))
mstore(0x4880, mulmod(1, mload(0x34e0), f_q))
{
            let result := mulmod(mload(0xae0), mload(0x30a0), f_q)
result := addmod(mulmod(mload(0xb00), mload(0x3100), f_q), result, f_q)
mstore(18592, result)
        }
mstore(0x48c0, mulmod(mload(0x48a0), mload(0x36e0), f_q))
mstore(0x48e0, mulmod(sub(f_q, mload(0x48c0)), 1, f_q))
mstore(0x4900, mulmod(mload(0x4880), 1, f_q))
mstore(0x4920, mulmod(mload(0x48e0), mload(0x38c0), f_q))
mstore(0x4940, mulmod(mload(0x4900), mload(0x38c0), f_q))
mstore(0x4960, addmod(mload(0x4860), mload(0x4920), f_q))
mstore(0x4980, mulmod(1, mload(0x2e20), f_q))
mstore(0x49a0, mulmod(1, mload(0xc60), f_q))
mstore(0x49c0, 0x0000000000000000000000000000000000000000000000000000000000000001)
                    mstore(0x49e0, 0x0000000000000000000000000000000000000000000000000000000000000002)
mstore(0x4a00, mload(0x4960))
success := and(eq(staticcall(gas(), 0x7, 0x49c0, 0x60, 0x49c0, 0x40), 1), success)
mstore(0x4a20, mload(0x49c0))
                    mstore(0x4a40, mload(0x49e0))
mstore(0x4a60, mload(0x220))
                    mstore(0x4a80, mload(0x240))
success := and(eq(staticcall(gas(), 0x6, 0x4a20, 0x80, 0x4a20, 0x40), 1), success)
mstore(0x4aa0, mload(0x260))
                    mstore(0x4ac0, mload(0x280))
mstore(0x4ae0, mload(0x3a20))
success := and(eq(staticcall(gas(), 0x7, 0x4aa0, 0x60, 0x4aa0, 0x40), 1), success)
mstore(0x4b00, mload(0x4a20))
                    mstore(0x4b20, mload(0x4a40))
mstore(0x4b40, mload(0x4aa0))
                    mstore(0x4b60, mload(0x4ac0))
success := and(eq(staticcall(gas(), 0x6, 0x4b00, 0x80, 0x4b00, 0x40), 1), success)
mstore(0x4b80, mload(0x2a0))
                    mstore(0x4ba0, mload(0x2c0))
mstore(0x4bc0, mload(0x4300))
success := and(eq(staticcall(gas(), 0x7, 0x4b80, 0x60, 0x4b80, 0x40), 1), success)
mstore(0x4be0, mload(0x4b00))
                    mstore(0x4c00, mload(0x4b20))
mstore(0x4c20, mload(0x4b80))
                    mstore(0x4c40, mload(0x4ba0))
success := and(eq(staticcall(gas(), 0x6, 0x4be0, 0x80, 0x4be0, 0x40), 1), success)
mstore(0x4c60, mload(0x380))
                    mstore(0x4c80, mload(0x3a0))
mstore(0x4ca0, mload(0x4320))
success := and(eq(staticcall(gas(), 0x7, 0x4c60, 0x60, 0x4c60, 0x40), 1), success)
mstore(0x4cc0, mload(0x4be0))
                    mstore(0x4ce0, mload(0x4c00))
mstore(0x4d00, mload(0x4c60))
                    mstore(0x4d20, mload(0x4c80))
success := and(eq(staticcall(gas(), 0x6, 0x4cc0, 0x80, 0x4cc0, 0x40), 1), success)
mstore(0x4d40, 0x0a56bb24bdbd10b2ae380a0f6d2926afe21e55ef423d664a7093bdc47d7a970d)
                    mstore(0x4d60, 0x3046067f3fbc66fb8322b30a454654489ad23370423a63caeab071e10143c65d)
mstore(0x4d80, mload(0x4340))
success := and(eq(staticcall(gas(), 0x7, 0x4d40, 0x60, 0x4d40, 0x40), 1), success)
mstore(0x4da0, mload(0x4cc0))
                    mstore(0x4dc0, mload(0x4ce0))
mstore(0x4de0, mload(0x4d40))
                    mstore(0x4e00, mload(0x4d60))
success := and(eq(staticcall(gas(), 0x6, 0x4da0, 0x80, 0x4da0, 0x40), 1), success)
mstore(0x4e20, 0x165f42d12623508ec09f1a14ffe3841e636362840bcfe45fd4f0847a50968d91)
                    mstore(0x4e40, 0x19664a50abfa10f51e0eb96bf39b959cd2ebd0ed52c60bc0d4e8535272a13ed9)
mstore(0x4e60, mload(0x4360))
success := and(eq(staticcall(gas(), 0x7, 0x4e20, 0x60, 0x4e20, 0x40), 1), success)
mstore(0x4e80, mload(0x4da0))
                    mstore(0x4ea0, mload(0x4dc0))
mstore(0x4ec0, mload(0x4e20))
                    mstore(0x4ee0, mload(0x4e40))
success := and(eq(staticcall(gas(), 0x6, 0x4e80, 0x80, 0x4e80, 0x40), 1), success)
mstore(0x4f00, 0x0c7dc4e4516515f0050b10e6891a60f39ab7645bbf2134080574b9ae26a3fee2)
                    mstore(0x4f20, 0x2ee3484a156715514bcc56f95e316bb23031b7460f679ebb427a7f8ad73aead2)
mstore(0x4f40, mload(0x4380))
success := and(eq(staticcall(gas(), 0x7, 0x4f00, 0x60, 0x4f00, 0x40), 1), success)
mstore(0x4f60, mload(0x4e80))
                    mstore(0x4f80, mload(0x4ea0))
mstore(0x4fa0, mload(0x4f00))
                    mstore(0x4fc0, mload(0x4f20))
success := and(eq(staticcall(gas(), 0x6, 0x4f60, 0x80, 0x4f60, 0x40), 1), success)
mstore(0x4fe0, 0x2fb1bc5dc1a8a163ac673f110c7ced2581955a8d47770fced15a66d8199a5c91)
                    mstore(0x5000, 0x18f7802cf51055b658637bf93f53fcc4dbe4218c03cb54c9d3e74534e1b9cb8f)
mstore(0x5020, mload(0x43a0))
success := and(eq(staticcall(gas(), 0x7, 0x4fe0, 0x60, 0x4fe0, 0x40), 1), success)
mstore(0x5040, mload(0x4f60))
                    mstore(0x5060, mload(0x4f80))
mstore(0x5080, mload(0x4fe0))
                    mstore(0x50a0, mload(0x5000))
success := and(eq(staticcall(gas(), 0x6, 0x5040, 0x80, 0x5040, 0x40), 1), success)
mstore(0x50c0, 0x2051ae2329a00ab4684564c9db909204379c6404686b9bb004253a0e87937c1a)
                    mstore(0x50e0, 0x2228d27991956786c7b7ed829027a4268a8f57d342e507683aaaea7046a1721b)
mstore(0x5100, mload(0x43c0))
success := and(eq(staticcall(gas(), 0x7, 0x50c0, 0x60, 0x50c0, 0x40), 1), success)
mstore(0x5120, mload(0x5040))
                    mstore(0x5140, mload(0x5060))
mstore(0x5160, mload(0x50c0))
                    mstore(0x5180, mload(0x50e0))
success := and(eq(staticcall(gas(), 0x6, 0x5120, 0x80, 0x5120, 0x40), 1), success)
mstore(0x51a0, 0x144e8b5cd066532d7a019f3061d407aeb922b3a37125d39cee71a336088a8d57)
                    mstore(0x51c0, 0x0465b8271620ef2988dbb05e0e32f58c14ee4aaec69263d36175afc35b129dc8)
mstore(0x51e0, mload(0x43e0))
success := and(eq(staticcall(gas(), 0x7, 0x51a0, 0x60, 0x51a0, 0x40), 1), success)
mstore(0x5200, mload(0x5120))
                    mstore(0x5220, mload(0x5140))
mstore(0x5240, mload(0x51a0))
                    mstore(0x5260, mload(0x51c0))
success := and(eq(staticcall(gas(), 0x6, 0x5200, 0x80, 0x5200, 0x40), 1), success)
mstore(0x5280, 0x2c5cb6e96533664432584b4373fc01286cb8aa2c8a7f05eac98fc5bc689e65bf)
                    mstore(0x52a0, 0x2c6a00e02442db4548c0583842d7c460dfaba5a8ae3d86ca57b0d7c82d7090c8)
mstore(0x52c0, mload(0x4400))
success := and(eq(staticcall(gas(), 0x7, 0x5280, 0x60, 0x5280, 0x40), 1), success)
mstore(0x52e0, mload(0x5200))
                    mstore(0x5300, mload(0x5220))
mstore(0x5320, mload(0x5280))
                    mstore(0x5340, mload(0x52a0))
success := and(eq(staticcall(gas(), 0x6, 0x52e0, 0x80, 0x52e0, 0x40), 1), success)
mstore(0x5360, 0x2b737ba20cacc46db1394cb36a1cb92566946b943314b7037d038fbb83f233a8)
                    mstore(0x5380, 0x04dc42ddd6eb4c1c43a1175bc70c5b5c92577f968055708b4beeb22cea5cff99)
mstore(0x53a0, mload(0x4420))
success := and(eq(staticcall(gas(), 0x7, 0x5360, 0x60, 0x5360, 0x40), 1), success)
mstore(0x53c0, mload(0x52e0))
                    mstore(0x53e0, mload(0x5300))
mstore(0x5400, mload(0x5360))
                    mstore(0x5420, mload(0x5380))
success := and(eq(staticcall(gas(), 0x6, 0x53c0, 0x80, 0x53c0, 0x40), 1), success)
mstore(0x5440, 0x0ff2ba345398269313967c25483b19e5e2de27f76a3a4357408c35dc42ddfec3)
                    mstore(0x5460, 0x063d5c171abc02e7d09324a4f1bb6493d0584767678901f452ebc7f285037015)
mstore(0x5480, mload(0x4440))
success := and(eq(staticcall(gas(), 0x7, 0x5440, 0x60, 0x5440, 0x40), 1), success)
mstore(0x54a0, mload(0x53c0))
                    mstore(0x54c0, mload(0x53e0))
mstore(0x54e0, mload(0x5440))
                    mstore(0x5500, mload(0x5460))
success := and(eq(staticcall(gas(), 0x6, 0x54a0, 0x80, 0x54a0, 0x40), 1), success)
mstore(0x5520, mload(0x620))
                    mstore(0x5540, mload(0x640))
mstore(0x5560, mload(0x4460))
success := and(eq(staticcall(gas(), 0x7, 0x5520, 0x60, 0x5520, 0x40), 1), success)
mstore(0x5580, mload(0x54a0))
                    mstore(0x55a0, mload(0x54c0))
mstore(0x55c0, mload(0x5520))
                    mstore(0x55e0, mload(0x5540))
success := and(eq(staticcall(gas(), 0x6, 0x5580, 0x80, 0x5580, 0x40), 1), success)
mstore(0x5600, mload(0x660))
                    mstore(0x5620, mload(0x680))
mstore(0x5640, mload(0x4480))
success := and(eq(staticcall(gas(), 0x7, 0x5600, 0x60, 0x5600, 0x40), 1), success)
mstore(0x5660, mload(0x5580))
                    mstore(0x5680, mload(0x55a0))
mstore(0x56a0, mload(0x5600))
                    mstore(0x56c0, mload(0x5620))
success := and(eq(staticcall(gas(), 0x6, 0x5660, 0x80, 0x5660, 0x40), 1), success)
mstore(0x56e0, mload(0x6a0))
                    mstore(0x5700, mload(0x6c0))
mstore(0x5720, mload(0x44a0))
success := and(eq(staticcall(gas(), 0x7, 0x56e0, 0x60, 0x56e0, 0x40), 1), success)
mstore(0x5740, mload(0x5660))
                    mstore(0x5760, mload(0x5680))
mstore(0x5780, mload(0x56e0))
                    mstore(0x57a0, mload(0x5700))
success := and(eq(staticcall(gas(), 0x6, 0x5740, 0x80, 0x5740, 0x40), 1), success)
mstore(0x57c0, mload(0x580))
                    mstore(0x57e0, mload(0x5a0))
mstore(0x5800, mload(0x44c0))
success := and(eq(staticcall(gas(), 0x7, 0x57c0, 0x60, 0x57c0, 0x40), 1), success)
mstore(0x5820, mload(0x5740))
                    mstore(0x5840, mload(0x5760))
mstore(0x5860, mload(0x57c0))
                    mstore(0x5880, mload(0x57e0))
success := and(eq(staticcall(gas(), 0x6, 0x5820, 0x80, 0x5820, 0x40), 1), success)
mstore(0x58a0, mload(0x480))
                    mstore(0x58c0, mload(0x4a0))
mstore(0x58e0, mload(0x4660))
success := and(eq(staticcall(gas(), 0x7, 0x58a0, 0x60, 0x58a0, 0x40), 1), success)
mstore(0x5900, mload(0x5820))
                    mstore(0x5920, mload(0x5840))
mstore(0x5940, mload(0x58a0))
                    mstore(0x5960, mload(0x58c0))
success := and(eq(staticcall(gas(), 0x6, 0x5900, 0x80, 0x5900, 0x40), 1), success)
mstore(0x5980, mload(0x4c0))
                    mstore(0x59a0, mload(0x4e0))
mstore(0x59c0, mload(0x4680))
success := and(eq(staticcall(gas(), 0x7, 0x5980, 0x60, 0x5980, 0x40), 1), success)
mstore(0x59e0, mload(0x5900))
                    mstore(0x5a00, mload(0x5920))
mstore(0x5a20, mload(0x5980))
                    mstore(0x5a40, mload(0x59a0))
success := and(eq(staticcall(gas(), 0x6, 0x59e0, 0x80, 0x59e0, 0x40), 1), success)
mstore(0x5a60, mload(0x500))
                    mstore(0x5a80, mload(0x520))
mstore(0x5aa0, mload(0x4820))
success := and(eq(staticcall(gas(), 0x7, 0x5a60, 0x60, 0x5a60, 0x40), 1), success)
mstore(0x5ac0, mload(0x59e0))
                    mstore(0x5ae0, mload(0x5a00))
mstore(0x5b00, mload(0x5a60))
                    mstore(0x5b20, mload(0x5a80))
success := and(eq(staticcall(gas(), 0x6, 0x5ac0, 0x80, 0x5ac0, 0x40), 1), success)
mstore(0x5b40, mload(0x540))
                    mstore(0x5b60, mload(0x560))
mstore(0x5b80, mload(0x4840))
success := and(eq(staticcall(gas(), 0x7, 0x5b40, 0x60, 0x5b40, 0x40), 1), success)
mstore(0x5ba0, mload(0x5ac0))
                    mstore(0x5bc0, mload(0x5ae0))
mstore(0x5be0, mload(0x5b40))
                    mstore(0x5c00, mload(0x5b60))
success := and(eq(staticcall(gas(), 0x6, 0x5ba0, 0x80, 0x5ba0, 0x40), 1), success)
mstore(0x5c20, mload(0x340))
                    mstore(0x5c40, mload(0x360))
mstore(0x5c60, mload(0x4940))
success := and(eq(staticcall(gas(), 0x7, 0x5c20, 0x60, 0x5c20, 0x40), 1), success)
mstore(0x5c80, mload(0x5ba0))
                    mstore(0x5ca0, mload(0x5bc0))
mstore(0x5cc0, mload(0x5c20))
                    mstore(0x5ce0, mload(0x5c40))
success := and(eq(staticcall(gas(), 0x6, 0x5c80, 0x80, 0x5c80, 0x40), 1), success)
mstore(0x5d00, mload(0xc00))
                    mstore(0x5d20, mload(0xc20))
mstore(0x5d40, sub(f_q, mload(0x4980)))
success := and(eq(staticcall(gas(), 0x7, 0x5d00, 0x60, 0x5d00, 0x40), 1), success)
mstore(0x5d60, mload(0x5c80))
                    mstore(0x5d80, mload(0x5ca0))
mstore(0x5da0, mload(0x5d00))
                    mstore(0x5dc0, mload(0x5d20))
success := and(eq(staticcall(gas(), 0x6, 0x5d60, 0x80, 0x5d60, 0x40), 1), success)
mstore(0x5de0, mload(0xca0))
                    mstore(0x5e00, mload(0xcc0))
mstore(0x5e20, mload(0x49a0))
success := and(eq(staticcall(gas(), 0x7, 0x5de0, 0x60, 0x5de0, 0x40), 1), success)
mstore(0x5e40, mload(0x5d60))
                    mstore(0x5e60, mload(0x5d80))
mstore(0x5e80, mload(0x5de0))
                    mstore(0x5ea0, mload(0x5e00))
success := and(eq(staticcall(gas(), 0x6, 0x5e40, 0x80, 0x5e40, 0x40), 1), success)
mstore(0x5ec0, mload(0x5e40))
                    mstore(0x5ee0, mload(0x5e60))
mstore(0x5f00, mload(0xca0))
                    mstore(0x5f20, mload(0xcc0))
mstore(0x5f40, mload(0xce0))
                    mstore(0x5f60, mload(0xd00))
mstore(0x5f80, mload(0xd20))
                    mstore(0x5fa0, mload(0xd40))
mstore(0x5fc0, keccak256(0x5ec0, 256))
mstore(24544, mod(mload(24512), f_q))
mstore(0x6000, mulmod(mload(0x5fe0), mload(0x5fe0), f_q))
mstore(0x6020, mulmod(1, mload(0x5fe0), f_q))
mstore(0x6040, mload(0x5f40))
                    mstore(0x6060, mload(0x5f60))
mstore(0x6080, mload(0x6020))
success := and(eq(staticcall(gas(), 0x7, 0x6040, 0x60, 0x6040, 0x40), 1), success)
mstore(0x60a0, mload(0x5ec0))
                    mstore(0x60c0, mload(0x5ee0))
mstore(0x60e0, mload(0x6040))
                    mstore(0x6100, mload(0x6060))
success := and(eq(staticcall(gas(), 0x6, 0x60a0, 0x80, 0x60a0, 0x40), 1), success)
mstore(0x6120, mload(0x5f80))
                    mstore(0x6140, mload(0x5fa0))
mstore(0x6160, mload(0x6020))
success := and(eq(staticcall(gas(), 0x7, 0x6120, 0x60, 0x6120, 0x40), 1), success)
mstore(0x6180, mload(0x5f00))
                    mstore(0x61a0, mload(0x5f20))
mstore(0x61c0, mload(0x6120))
                    mstore(0x61e0, mload(0x6140))
success := and(eq(staticcall(gas(), 0x6, 0x6180, 0x80, 0x6180, 0x40), 1), success)
mstore(0x6200, mload(0x60a0))
                    mstore(0x6220, mload(0x60c0))
mstore(0x6240, 0x198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2)
            mstore(0x6260, 0x1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed)
            mstore(0x6280, 0x090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b)
            mstore(0x62a0, 0x12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa)
mstore(0x62c0, mload(0x6180))
                    mstore(0x62e0, mload(0x61a0))
mstore(0x6300, 0x138d5863615c12d3bd7d3fd007776d281a337f9d7f6dce23532100bb4bb5839d)
            mstore(0x6320, 0x0a3bb881671ee4e9238366e87f6598f0de356372ed3dc870766ec8ac005211e4)
            mstore(0x6340, 0x19c9d7d9c6e7ad2d9a0d5847ebdd2687c668939a202553ded2760d3eb8dbf559)
            mstore(0x6360, 0x198adb441818c42721c88c532ed13a5da1ebb78b85574d0b7326d8e6f4c1e25a)
success := and(eq(staticcall(gas(), 0x8, 0x6200, 0x180, 0x6200, 0x20), 1), success)
success := and(eq(mload(0x6200), 1), success)

            // Revert if anything fails
            if iszero(success) { revert(0, 0) }

            // Return empty bytes on success
            return(0, 0)

        }
    }
}