{
    "Function": "sha1",
    "File": "packages/protocol/contracts/automata-attestation/utils/SHA1.sol",
    "Parent Contracts": [],
    "High-Level Calls": [],
    "Internal Calls": [
        "mload(uint256)",
        "mload(uint256)",
        "mload(uint256)",
        "mload(uint256)",
        "mload(uint256)",
        "mload(uint256)",
        "mstore(uint256,uint256)",
        "mload(uint256)",
        "mload(uint256)",
        "mload(uint256)",
        "mstore(uint256,uint256)",
        "mload(uint256)",
        "mstore(uint256,uint256)",
        "mstore(uint256,uint256)",
        "readword",
        "mstore(uint256,uint256)",
        "mload(uint256)",
        "readword",
        "mload(uint256)",
        "mstore8(uint256,uint256)"
    ],
    "Library Calls": [],
    "Low-Level Calls": [],
    "Code": "function sha1(bytes memory data) internal pure returns (bytes20 ret) {\n        assembly {\n            // Get a safe scratch location\n            let scratch := mload(0x40)\n\n            // Get the data length, and point data at the first byte\n            let len := mload(data)\n            data := add(data, 32)\n\n            // Find the length after padding\n            let totallen := add(and(add(len, 1), 0xFFFFFFFFFFFFFFC0), 64)\n            switch lt(sub(totallen, len), 9)\n            case 1 { totallen := add(totallen, 64) }\n\n            let h := 0x6745230100EFCDAB890098BADCFE001032547600C3D2E1F0\n\n            function readword(ptr, off, count) -> result {\n                result := 0\n                if lt(off, count) {\n                    result := mload(add(ptr, off))\n                    count := sub(count, off)\n                    if lt(count, 32) {\n                        let mask := not(sub(exp(256, sub(32, count)), 1))\n                        result := and(result, mask)\n                    }\n                }\n            }\n\n            for { let i := 0 } lt(i, totallen) { i := add(i, 64) } {\n                mstore(scratch, readword(data, i, len))\n                mstore(add(scratch, 32), readword(data, add(i, 32), len))\n\n                // If we loaded the last byte, store the terminator byte\n                switch lt(sub(len, i), 64)\n                case 1 { mstore8(add(scratch, sub(len, i)), 0x80) }\n\n                // If this is the last block, store the length\n                switch eq(i, sub(totallen, 64))\n                case 1 { mstore(add(scratch, 32), or(mload(add(scratch, 32)), mul(len, 8))) }\n\n                // Expand the 16 32-bit words into 80\n                for { let j := 64 } lt(j, 128) { j := add(j, 12) } {\n                    let temp :=\n                        xor(\n                            xor(mload(add(scratch, sub(j, 12))), mload(add(scratch, sub(j, 32)))),\n                            xor(mload(add(scratch, sub(j, 56))), mload(add(scratch, sub(j, 64))))\n                        )\n                    temp :=\n                        or(\n                            and(\n                                mul(temp, 2),\n                                0xFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFE\n                            ),\n                            and(\n                                div(temp, 0x80000000),\n                                0x0000000100000001000000010000000100000001000000010000000100000001\n                            )\n                        )\n                    mstore(add(scratch, j), temp)\n                }\n                for { let j := 128 } lt(j, 320) { j := add(j, 24) } {\n                    let temp :=\n                        xor(\n                            xor(mload(add(scratch, sub(j, 24))), mload(add(scratch, sub(j, 64)))),\n                            xor(mload(add(scratch, sub(j, 112))), mload(add(scratch, sub(j, 128))))\n                        )\n                    temp :=\n                        or(\n                            and(\n                                mul(temp, 4),\n                                0xFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFC\n                            ),\n                            and(\n                                div(temp, 0x40000000),\n                                0x0000000300000003000000030000000300000003000000030000000300000003\n                            )\n                        )\n                    mstore(add(scratch, j), temp)\n                }\n\n                let x := h\n                let f := 0\n                let k := 0\n                for { let j := 0 } lt(j, 80) { j := add(j, 1) } {\n                    switch div(j, 20)\n                    case 0 {\n                        // f = d xor (b and (c xor d))\n                        f := xor(div(x, 0x100000000000000000000), div(x, 0x10000000000))\n                        f := and(div(x, 0x1000000000000000000000000000000), f)\n                        f := xor(div(x, 0x10000000000), f)\n                        k := 0x5A827999\n                    }\n                    case 1 {\n                        // f = b xor c xor d\n                        f :=\n                            xor(\n                                div(x, 0x1000000000000000000000000000000),\n                                div(x, 0x100000000000000000000)\n                            )\n                        f := xor(div(x, 0x10000000000), f)\n                        k := 0x6ED9EBA1\n                    }\n                    case 2 {\n                        // f = (b and c) or (d and (b or c))\n                        f :=\n                            or(\n                                div(x, 0x1000000000000000000000000000000),\n                                div(x, 0x100000000000000000000)\n                            )\n                        f := and(div(x, 0x10000000000), f)\n                        f :=\n                            or(\n                                and(\n                                    div(x, 0x1000000000000000000000000000000),\n                                    div(x, 0x100000000000000000000)\n                                ),\n                                f\n                            )\n                        k := 0x8F1BBCDC\n                    }\n                    case 3 {\n                        // f = b xor c xor d\n                        f :=\n                            xor(\n                                div(x, 0x1000000000000000000000000000000),\n                                div(x, 0x100000000000000000000)\n                            )\n                        f := xor(div(x, 0x10000000000), f)\n                        k := 0xCA62C1D6\n                    }\n                    // temp = (a leftrotate 5) + f + e + k + w[i]\n                    let temp := and(div(x, 0x80000000000000000000000000000000000000000000000), 0x1F)\n                    temp :=\n                        or(and(div(x, 0x800000000000000000000000000000000000000), 0xFFFFFFE0), temp)\n                    temp := add(f, temp)\n                    temp := add(and(x, 0xFFFFFFFF), temp)\n                    temp := add(k, temp)\n                    temp :=\n                        add(\n                            div(\n                                mload(add(scratch, mul(j, 4))),\n                                0x100000000000000000000000000000000000000000000000000000000\n                            ),\n                            temp\n                        )\n                    x :=\n                        or(\n                            div(x, 0x10000000000),\n                            mul(temp, 0x10000000000000000000000000000000000000000)\n                        )\n                    x :=\n                        or(\n                            and(x, 0xFFFFFFFF00FFFFFFFF000000000000FFFFFFFF00FFFFFFFF),\n                            mul(\n                                or(\n                                    and(div(x, 0x4000000000000), 0xC0000000),\n                                    and(div(x, 0x400000000000000000000), 0x3FFFFFFF)\n                                ),\n                                0x100000000000000000000\n                            )\n                        )\n                }\n\n                h := and(add(h, x), 0xFFFFFFFF00FFFFFFFF00FFFFFFFF00FFFFFFFF00FFFFFFFF)\n            }\n            ret :=\n                mul(\n                    or(\n                        or(\n                            or(\n                                or(\n                                    and(div(h, 0x100000000), 0xFFFFFFFF00000000000000000000000000000000),\n                                    and(div(h, 0x1000000), 0xFFFFFFFF000000000000000000000000)\n                                ),\n                                and(div(h, 0x10000), 0xFFFFFFFF0000000000000000)\n                            ),\n                            and(div(h, 0x100), 0xFFFFFFFF00000000)\n                        ),\n                        and(h, 0xFFFFFFFF)\n                    ),\n                    0x1000000000000000000000000\n                )\n        }\n    }"
}