Contract Overview
Balance:
0 ETH
EtherValue:
$0.00
My Name Tag:
Not Available, login to update
Txn Hash | Method |
Block
|
From
|
To
|
Value | ||||
---|---|---|---|---|---|---|---|---|---|
0x686b8511f144d9dbbddebfcd2950f2096900292a8325f7de0b4a30bf45e8a461 | 0x60a06040 | 13825310 | 633 days 18 hrs ago | Firn: Deployer | IN | Create: DepositVerifier | 0 ETH | 0.004146973882 |
[ Download CSV Export ]
View more zero value Internal Transactions in Advanced View mode
Contract Name:
DepositVerifier
Compiler Version
v0.8.15+commit.e14f2714
Contract Source Code (Solidity Multiple files format)
// SPDX-License-Identifier: Apache-2.0 pragma solidity 0.8.15; import "./IDepositVerifier.sol"; import "./InnerProductVerifier.sol"; import "./Utils.sol"; contract DepositVerifier is IDepositVerifier { using Utils for uint256; using Utils for Utils.Point; InnerProductVerifier immutable innerProductVerifier; constructor(address _innerProductVerifier) { innerProductVerifier = InnerProductVerifier(_innerProductVerifier); } function g() internal view returns (Utils.Point memory) { return Utils.Point(innerProductVerifier.gX(), innerProductVerifier.gY()); } function h() internal view returns (Utils.Point memory) { return Utils.Point(innerProductVerifier.hX(), innerProductVerifier.hY()); } function gs(uint256 i) internal view returns (Utils.Point memory) { (bytes32 x, bytes32 y) = innerProductVerifier.gs(i); return Utils.Point(x, y); } function hs(uint256 i) internal view returns (Utils.Point memory) { (bytes32 x, bytes32 y) = innerProductVerifier.hs(i); return Utils.Point(x, y); } struct Locals { uint256 v; uint256 w; uint256 vPow; uint256 wPow; uint256[n][2] f; // could just allocate extra space in the proof? uint256[N] r; // each poly is an array of length N. evaluations of prods Utils.Point temp; Utils.Point C_XR; Utils.Point y_XR; uint256 c; Utils.Point A_D; Utils.Point A_X; } function verify(uint256 amount, Utils.Statement calldata statement, Utils.DepositProof calldata proof) external view { Locals memory locals; locals.v = uint256(keccak256(abi.encode(amount, statement.Y, statement.C, statement.D, proof.A, proof.B))).mod(); locals.w = uint256(keccak256(abi.encode(locals.v, proof.C_XG, proof.y_XG))).mod(); for (uint256 k = 0; k < n; k++) { locals.f[1][k] = proof.f[k]; locals.f[0][k] = locals.w.sub(proof.f[k]); locals.temp = locals.temp.add(gs(k).mul(locals.f[1][k])); locals.temp = locals.temp.add(hs(k).mul(locals.f[1][k].mul(locals.f[0][k]))); } require(proof.B.mul(locals.w).add(proof.A).eq(locals.temp.add(h().mul(proof.z_A))), "Bit-proof verification failed."); locals.r = Utils.assemblePolynomials(locals.f); locals.wPow = 1; for (uint256 k = 0; k < n; k++) { locals.C_XR = locals.C_XR.add(proof.C_XG[k].mul(locals.wPow.neg())); locals.y_XR = locals.y_XR.add(proof.y_XG[k].mul(locals.wPow.neg())); locals.wPow = locals.wPow.mul(locals.w); } locals.vPow = locals.v; // used to be 1 for (uint256 i = 0; i < N; i++) { uint256 multiplier = locals.r[i].add(locals.vPow.mul(locals.wPow.sub(locals.r[i]))); // locals. ? locals.C_XR = locals.C_XR.add(statement.C[i].mul(multiplier)); locals.y_XR = locals.y_XR.add(statement.Y[i].mul(multiplier)); locals.vPow = locals.vPow.mul(locals.v); // used to do this only if (i > 0) } locals.C_XR = locals.C_XR.add(g().mul(amount.neg().mul(locals.wPow))); // this line is new locals.A_D = g().mul(proof.s_r).add(statement.D.mul(proof.c.neg())); // add(mul(locals.gR, proof.s_r), mul(locals.DR, proof.c.neg())); locals.A_X = locals.y_XR.mul(proof.s_r).add(locals.C_XR.mul(proof.c.neg())); locals.c = uint256(keccak256(abi.encode(locals.v, locals.A_D, locals.A_X))).mod(); require(locals.c == proof.c, "Sigma protocol failure."); } }
// SPDX-License-Identifier: Apache-2.0 pragma solidity 0.8.15; import "./Utils.sol"; interface IDepositVerifier { function verify(uint256 amount, Utils.Statement calldata statement, Utils.DepositProof calldata proof) external view; }
// SPDX-License-Identifier: Apache-2.0 pragma solidity 0.8.15; import "./Utils.sol"; contract InnerProductVerifier { using Utils for uint256; using Utils for Utils.Point; bytes32 public immutable gX; bytes32 public immutable gY; bytes32 public immutable hX; bytes32 public immutable hY; // above, emulating immutable `Utils.Point`s using raw `bytes32`s. save some sloads later. Utils.Point[M << 1] public gs; Utils.Point[M << 1] public hs; // have to use storage, not immutable, because solidity doesn't support non-primitive immutable types constructor() { Utils.Point memory gTemp = Utils.mapInto("g"); gX = gTemp.x; gY = gTemp.y; Utils.Point memory hTemp = Utils.mapInto("h"); hX = hTemp.x; hY = hTemp.y; for (uint256 i = 0; i < M << 1; i++) { gs[i] = Utils.mapInto("g", i); hs[i] = Utils.mapInto("h", i); } } struct Locals { uint256 o; Utils.Point P; uint256[m + 1] challenges; uint256[M << 1] s; } function verify(Utils.InnerProductStatement calldata statement, Utils.InnerProductProof calldata proof, bool transfer) external view { Locals memory locals; locals.o = statement.salt; locals.P = statement.P; uint256 M_ = M << (transfer ? 1 : 0); uint256 m_ = m + (transfer ? 1 : 0); for (uint256 i = 0; i < m_; i++) { locals.o = uint256(keccak256(abi.encode(locals.o, proof.L[i], proof.R[i]))).mod(); // overwrites locals.challenges[i] = locals.o; uint256 inverse = locals.o.inv(); locals.P = locals.P.add(proof.L[i].mul(locals.o.mul(locals.o))).add(proof.R[i].mul(inverse.mul(inverse))); } locals.s[0] = 1; for (uint256 i = 0; i < m_; i++) locals.s[0] = locals.s[0].mul(locals.challenges[i]); locals.s[0] = locals.s[0].inv(); for (uint256 i = 0; i < m_; i++) { for (uint256 j = 0; j < M_; j += 1 << m_ - i) { locals.s[j + (1 << m_ - i - 1)] = locals.s[j].mul(locals.challenges[i]).mul(locals.challenges[i]); } } Utils.Point memory temp = statement.u.mul(proof.a.mul(proof.b)); for (uint256 i = 0; i < M_; i++) { temp = temp.add(gs[i].mul(locals.s[i].mul(proof.a))); temp = temp.add(statement.hs[i].mul(locals.s[M_ - 1 - i].mul(proof.b))); } require(temp.eq(locals.P), "Inner product proof failed."); } }
// SPDX-License-Identifier: Apache-2.0 pragma solidity 0.8.15; uint256 constant n = 4; uint256 constant N = 1 << n; uint256 constant m = 5; uint256 constant M = 1 << m; library Utils { uint256 constant GROUP_ORDER = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001; uint256 constant FIELD_ORDER = 0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47; uint256 constant PPLUS1DIV4 = 0x0c19139cb84c680a6e14116da060561765e05aa45a1c72a34f082305b61f3f52; function add(uint256 x, uint256 y) internal pure returns (uint256) { return addmod(x, y, GROUP_ORDER); } function mul(uint256 x, uint256 y) internal pure returns (uint256) { return mulmod(x, y, GROUP_ORDER); } function inv(uint256 x) internal view returns (uint256) { return exp(x, GROUP_ORDER - 2); } function mod(uint256 x) internal pure returns (uint256) { return x % GROUP_ORDER; } function sub(uint256 x, uint256 y) internal pure returns (uint256) { return x >= y ? x - y : GROUP_ORDER - y + x; } function neg(uint256 x) internal pure returns (uint256) { return GROUP_ORDER - x; } function exp(uint256 base, uint256 exponent) internal view returns (uint256 output) { uint256 order = GROUP_ORDER; assembly { let location := mload(0x40) mstore(location, 0x20) mstore(add(location, 0x20), 0x20) mstore(add(location, 0x40), 0x20) mstore(add(location, 0x60), base) mstore(add(location, 0x80), exponent) mstore(add(location, 0xa0), order) if iszero(staticcall(gas(), 0x05, location, 0xc0, location, 0x20)) { revert(0, 0) } output := mload(location) } } function fieldExp(uint256 base, uint256 exponent) internal view returns (uint256 output) { // warning: mod p, not q uint256 order = FIELD_ORDER; assembly { let location := mload(0x40) mstore(location, 0x20) mstore(add(location, 0x20), 0x20) mstore(add(location, 0x40), 0x20) mstore(add(location, 0x60), base) mstore(add(location, 0x80), exponent) mstore(add(location, 0xa0), order) if iszero(staticcall(gas(), 0x05, location, 0xc0, location, 0x20)) { revert(0, 0) } output := mload(location) } } struct Point { bytes32 x; bytes32 y; } function add(Point memory p1, Point memory p2) internal view returns (Point memory r) { assembly { let location := mload(0x40) mstore(location, mload(p1)) mstore(add(location, 0x20), mload(add(p1, 0x20))) mstore(add(location, 0x40), mload(p2)) mstore(add(location, 0x60), mload(add(p2, 0x20))) if iszero(staticcall(gas(), 0x06, location, 0x80, r, 0x40)) { revert(0, 0) } } } function mul(Point memory p, uint256 s) internal view returns (Point memory r) { assembly { let location := mload(0x40) mstore(location, mload(p)) mstore(add(location, 0x20), mload(add(p, 0x20))) mstore(add(location, 0x40), s) if iszero(staticcall(gas(), 0x07, location, 0x60, r, 0x40)) { revert(0, 0) } } } function neg(Point memory p) internal pure returns (Point memory) { return Point(p.x, bytes32(FIELD_ORDER - uint256(p.y))); // p.y should already be reduced mod P? } function eq(Point memory p1, Point memory p2) internal pure returns (bool) { return p1.x == p2.x && p1.y == p2.y; } function decompress(bytes32 input) internal view returns (Point memory) { if (input == 0x00) return Point(0x00, 0x00); uint256 x = uint256(input); uint256 sign = (x & 0x8000000000000000000000000000000000000000000000000000000000000000) >> 255; x &= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; uint256 ySquared = fieldExp(x, 3) + 3; uint256 y = fieldExp(ySquared, PPLUS1DIV4); Point memory result = Point(bytes32(x), bytes32(y)); if (sign != y & 0x01) return neg(result); return result; } function compress(Point memory input) internal pure returns (bytes32) { uint256 result = uint256(input.x); if (uint256(input.y) & 0x01 == 0x01) result |= 0x8000000000000000000000000000000000000000000000000000000000000000; return bytes32(result); } function mapInto(uint256 seed) internal view returns (Point memory) { uint256 y; while (true) { uint256 ySquared = fieldExp(seed, 3) + 3; // addmod instead of add: waste of gas, plus function overhead cost y = fieldExp(ySquared, PPLUS1DIV4); if (fieldExp(y, 2) == ySquared) { break; } seed += 1; } return Point(bytes32(seed), bytes32(y)); } function mapInto(string memory input) internal view returns (Point memory) { return mapInto(uint256(keccak256(abi.encodePacked(input))) % FIELD_ORDER); } function mapInto(string memory input, uint256 i) internal view returns (Point memory) { return mapInto(uint256(keccak256(abi.encodePacked(input, i))) % FIELD_ORDER); } function slice(bytes memory input, uint256 start) internal pure returns (bytes32 result) { assembly { result := mload(add(add(input, 0x20), start)) } } struct Statement { Point[N] Y; Point[N] CLn; Point[N] CRn; Point[N] C; Point D; uint256 epoch; Point u; uint256 fee; } struct DepositProof { Point A; Point B; Point[n] C_XG; Point[n] y_XG; uint256[n] f; uint256 z_A; uint256 c; uint256 s_r; } function deserializeDeposit(bytes memory arr) internal view returns (DepositProof memory proof) { proof.A = decompress(slice(arr, 0)); proof.B = decompress(slice(arr, 32)); for (uint256 k = 0; k < n; k++) { proof.C_XG[k] = decompress(slice(arr, 64 + k * 32)); proof.y_XG[k] = decompress(slice(arr, 64 + (k + n) * 32)); proof.f[k] = uint256(slice(arr, 64 + n * 64 + k * 32)); } uint256 starting = n * 96; proof.z_A = uint256(slice(arr, 64 + starting)); proof.c = uint256(slice(arr, 96 + starting)); proof.s_r = uint256(slice(arr, 128 + starting)); return proof; } struct TransferProof { Point BA; Point BS; Point A; Point B; Point[n] CLnG; Point[n] CRnG; Point[n] C_0G; Point[n] DG; Point[n] y_0G; Point[n] gG; Point[n] C_XG; Point[n] y_XG; uint256[n][2] f; uint256 z_A; Point T_1; Point T_2; uint256 tHat; uint256 mu; uint256 c; uint256 s_sk; uint256 s_r; uint256 s_b; uint256 s_tau; InnerProductProof ip; } function deserializeTransfer(bytes memory arr) internal view returns (TransferProof memory proof) { proof.BA = decompress(slice(arr, 0)); proof.BS = decompress(slice(arr, 32)); proof.A = decompress(slice(arr, 64)); proof.B = decompress(slice(arr, 96)); for (uint256 k = 0; k < n; k++) { proof.CLnG[k] = decompress(slice(arr, 128 + k * 32)); proof.CRnG[k] = decompress(slice(arr, 128 + (k + n) * 32)); proof.C_0G[k] = decompress(slice(arr, 128 + n * 64 + k * 32)); proof.DG[k] = decompress(slice(arr, 128 + n * 96 + k * 32)); proof.y_0G[k] = decompress(slice(arr, 128 + n * 128 + k * 32)); proof.gG[k] = decompress(slice(arr, 128 + n * 160 + k * 32)); proof.C_XG[k] = decompress(slice(arr, 128 + n * 192 + k * 32)); proof.y_XG[k] = decompress(slice(arr, 128 + n * 224 + k * 32)); proof.f[0][k] = uint256(slice(arr, 128 + n * 256 + k * 32)); proof.f[1][k] = uint256(slice(arr, 128 + n * 288 + k * 32)); } uint256 starting = n * 320; proof.z_A = uint256(slice(arr, 128 + starting)); proof.T_1 = decompress(slice(arr, 160 + starting)); proof.T_2 = decompress(slice(arr, 192 + starting)); proof.tHat = uint256(slice(arr, 224 + starting)); proof.mu = uint256(slice(arr, 256 + starting)); proof.c = uint256(slice(arr, 288 + starting)); proof.s_sk = uint256(slice(arr, 320 + starting)); proof.s_r = uint256(slice(arr, 352 + starting)); proof.s_b = uint256(slice(arr, 384 + starting)); proof.s_tau = uint256(slice(arr, 416 + starting)); for (uint256 i = 0; i < m + 1; i++) { proof.ip.L[i] = decompress(slice(arr, 448 + starting + i * 32)); proof.ip.R[i] = decompress(slice(arr, 448 + starting + (i + m + 1) * 32)); } proof.ip.a = uint256(slice(arr, 448 + starting + (m + 1) * 64)); proof.ip.b = uint256(slice(arr, 480 + starting + (m + 1) * 64)); return proof; } struct WithdrawalProof { Point BA; Point BS; Point A; Point B; Point[n] CLnG; Point[n] CRnG; Point[n] y_0G; Point[n] gG; Point[n] C_XG; Point[n] y_XG; uint256[n] f; uint256 z_A; Point T_1; Point T_2; uint256 tHat; uint256 mu; uint256 c; uint256 s_sk; uint256 s_r; uint256 s_b; uint256 s_tau; InnerProductProof ip; } function deserializeWithdrawal(bytes memory arr) internal view returns (WithdrawalProof memory proof) { proof.BA = decompress(slice(arr, 0)); proof.BS = decompress(slice(arr, 32)); proof.A = decompress(slice(arr, 64)); proof.B = decompress(slice(arr, 96)); for (uint256 k = 0; k < n; k++) { proof.CLnG[k] = decompress(slice(arr, 128 + k * 32)); proof.CRnG[k] = decompress(slice(arr, 128 + (k + n) * 32)); proof.y_0G[k] = decompress(slice(arr, 128 + n * 64 + k * 32)); proof.gG[k] = decompress(slice(arr, 128 + n * 96 + k * 32)); proof.C_XG[k] = decompress(slice(arr, 128 + n * 128 + k * 32)); proof.y_XG[k] = decompress(slice(arr, 128 + n * 160 + k * 32)); proof.f[k] = uint256(slice(arr, 128 + n * 192 + k * 32)); } uint256 starting = n * 224; proof.z_A = uint256(slice(arr, 128 + starting)); proof.T_1 = decompress(slice(arr, 160 + starting)); proof.T_2 = decompress(slice(arr, 192 + starting)); proof.tHat = uint256(slice(arr, 224 + starting)); proof.mu = uint256(slice(arr, 256 + starting)); proof.c = uint256(slice(arr, 288 + starting)); proof.s_sk = uint256(slice(arr, 320 + starting)); proof.s_r = uint256(slice(arr, 352 + starting)); proof.s_b = uint256(slice(arr, 384 + starting)); proof.s_tau = uint256(slice(arr, 416 + starting)); for (uint256 i = 0; i < m; i++) { // will leave the `m`th element empty proof.ip.L[i] = decompress(slice(arr, 448 + starting + i * 32)); proof.ip.R[i] = decompress(slice(arr, 448 + starting + (i + m) * 32)); } proof.ip.a = uint256(slice(arr, 448 + starting + m * 64)); proof.ip.b = uint256(slice(arr, 480 + starting + m * 64)); return proof; } struct InnerProductStatement { uint256 salt; Point[M << 1] hs; // "overridden" parameters. Point u; Point P; } struct InnerProductProof { Point[m + 1] L; Point[m + 1] R; uint256 a; uint256 b; } function assemblePolynomials(uint256[n][2] memory f) internal pure returns (uint256[N] memory result) { // f is a 2m-by-2 array... containing the f's and x - f's, twice (i.e., concatenated). // output contains two "rows", each of length N. result[0] = 1; for (uint256 k = 0; k < n; k++) { for (uint256 i = 0; i < N; i += 1 << n - k) { result[i + (1 << n - 1 - k)] = mul(result[i], f[1][n - 1 - k]); result[i] = mul(result[i], f[0][n - 1 - k]); } } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_innerProductVerifier","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"components":[{"components":[{"internalType":"bytes32","name":"x","type":"bytes32"},{"internalType":"bytes32","name":"y","type":"bytes32"}],"internalType":"struct Utils.Point[16]","name":"Y","type":"tuple[16]"},{"components":[{"internalType":"bytes32","name":"x","type":"bytes32"},{"internalType":"bytes32","name":"y","type":"bytes32"}],"internalType":"struct Utils.Point[16]","name":"CLn","type":"tuple[16]"},{"components":[{"internalType":"bytes32","name":"x","type":"bytes32"},{"internalType":"bytes32","name":"y","type":"bytes32"}],"internalType":"struct Utils.Point[16]","name":"CRn","type":"tuple[16]"},{"components":[{"internalType":"bytes32","name":"x","type":"bytes32"},{"internalType":"bytes32","name":"y","type":"bytes32"}],"internalType":"struct Utils.Point[16]","name":"C","type":"tuple[16]"},{"components":[{"internalType":"bytes32","name":"x","type":"bytes32"},{"internalType":"bytes32","name":"y","type":"bytes32"}],"internalType":"struct Utils.Point","name":"D","type":"tuple"},{"internalType":"uint256","name":"epoch","type":"uint256"},{"components":[{"internalType":"bytes32","name":"x","type":"bytes32"},{"internalType":"bytes32","name":"y","type":"bytes32"}],"internalType":"struct Utils.Point","name":"u","type":"tuple"},{"internalType":"uint256","name":"fee","type":"uint256"}],"internalType":"struct Utils.Statement","name":"statement","type":"tuple"},{"components":[{"components":[{"internalType":"bytes32","name":"x","type":"bytes32"},{"internalType":"bytes32","name":"y","type":"bytes32"}],"internalType":"struct Utils.Point","name":"A","type":"tuple"},{"components":[{"internalType":"bytes32","name":"x","type":"bytes32"},{"internalType":"bytes32","name":"y","type":"bytes32"}],"internalType":"struct Utils.Point","name":"B","type":"tuple"},{"components":[{"internalType":"bytes32","name":"x","type":"bytes32"},{"internalType":"bytes32","name":"y","type":"bytes32"}],"internalType":"struct Utils.Point[4]","name":"C_XG","type":"tuple[4]"},{"components":[{"internalType":"bytes32","name":"x","type":"bytes32"},{"internalType":"bytes32","name":"y","type":"bytes32"}],"internalType":"struct Utils.Point[4]","name":"y_XG","type":"tuple[4]"},{"internalType":"uint256[4]","name":"f","type":"uint256[4]"},{"internalType":"uint256","name":"z_A","type":"uint256"},{"internalType":"uint256","name":"c","type":"uint256"},{"internalType":"uint256","name":"s_r","type":"uint256"}],"internalType":"struct Utils.DepositProof","name":"proof","type":"tuple"}],"name":"verify","outputs":[],"stateMutability":"view","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000cef468199f67ea54cd326d6470defd69378ea92b
-----Decoded View---------------
Arg [0] : _innerProductVerifier (address): 0xcef468199f67EA54CD326D6470DefD69378Ea92B
-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000cef468199f67ea54cd326d6470defd69378ea92b
Deployed ByteCode Sourcemap
158:3454:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1524:2086;;;;;;:::i;:::-;;:::i;:::-;;;1651:20;;:::i;:::-;1777:7;1710:75;;1692:101;;1710:75;;1721:6;;1729:9;;1742:11;;;;1755;;;;1768:5;;1777:7;;;1710:75;;;:::i;:::-;;;;;;;;;;;;;1700:86;;;;;;1692:95;;:99;:101::i;:::-;1681:112;;;1832:44;;1814:70;;1832:44;;1853:10;;;;1865;;;;1832:44;;;:::i;1814:70::-;1803:8;;;:81;1899:9;1894:300;86:1:3;1914::0;:5;1894:300;;;1957:5;:7;;1965:1;1957:10;;;;;;;:::i;:::-;;;;;1940:6;:8;;;1949:1;1940:11;;;;;;;:::i;:::-;;;;;1952:1;1940:14;;;;;;;:::i;:::-;;;;:27;1998:24;2011:7;;;2019:1;2011:10;;;;;;;:::i;:::-;;1998:8;;;;;2011:10;;;;1998:12;:24::i;:::-;1981:8;;;;:11;1993:1;1981:14;;;;;;;:::i;:::-;;;;:41;2077:8;;;;2051:42;;2067:25;;2086:1;2077:11;;;;2089:1;2077:14;;;;;;;:::i;:::-;;;;;2067:5;2070:1;2067:2;:5::i;:::-;:9;;:25::i;:::-;2051:11;;;;;:15;:42::i;:::-;2037:11;;;:56;2166:8;;;;:11;2121:62;;2137:45;;2147:34;;2178:1;2166:14;;;;;;;:::i;:::-;;;;;2147:8;;;;2156:1;2147:11;;;;2159:1;2147:14;;;;;;;:::i;:::-;;;;;;:18;:34::i;:::-;2137:5;2140:1;2137:2;:5::i;2121:62::-;2107:11;;;:76;1921:3;;;;:::i;:::-;;;;1894:300;;;;2211:74;2249:35;2265:18;2273:5;:9;;;2265:3;:1;:3::i;2249:35::-;2211:34;;;;;;;;2237:5;2211:34;:::i;:::-;2223:8;;;;2211:21;;:11;;;;;;;:7;;;:11;:::i;:21::-;:25;;:34::i;:::-;:37;;:74::i;:::-;2203:117;;;;;;;4654:2:4;2203:117:0;;;4636:21:4;4693:2;4673:18;;;4666:30;4732:32;4712:18;;;4705:60;4782:18;;2203:117:0;;;;;;;;;2342:35;2368:6;:8;;;2342:25;:35::i;:::-;2331:8;;;:46;2401:1;2387:11;;;:15;-1:-1:-1;2412:259:0;86:1:3;2432::0;:5;2412:259;;;2472:53;2488:36;2506:17;:6;:11;;;:15;:17::i;:::-;2488:5;:10;;2499:1;2488:13;;;;;;;:::i;:::-;;;;:17;;;;;;;;;;:::i;:36::-;2472:11;;;;;:15;:53::i;:::-;2458:6;:11;;:67;;;;2553:53;2569:36;2587:17;:6;:11;;;:15;:17::i;:::-;2569:5;:10;;2580:1;2569:13;;;;;;;:::i;:36::-;2553:11;;;;;:15;:53::i;:::-;2539:11;;;:67;2651:8;;;;2635:11;;;;:25;;:15;:25::i;:::-;2621:11;;;:39;2439:3;;;;:::i;:::-;;;;2412:259;;;-1:-1:-1;2694:8:0;;2680:11;;;:22;2694:8;2728:391;110:6:3;2748:5:0;;2728:391;;;2774:18;2795:62;2811:45;2827:28;2843:6;:8;;;2852:1;2843:11;;;;;;;:::i;:::-;;;;;2827;;;;;:15;:28::i;:::-;2811:11;;;;;:15;:45::i;:::-;2795:6;:8;;;2804:1;2795:11;;;;;;;:::i;:::-;;;;;;:15;:62::i;:::-;2774:83;;2898:47;2914:30;2933:10;2914:9;:11;;2926:1;2914:14;;;;;;;:::i;:30::-;2898:11;;;;;:15;:47::i;:::-;2884:11;;;:61;2973:47;2989:30;3008:10;2989:9;3001:1;2989:14;;;;;;;:::i;:30::-;2973:11;;;;;:15;:47::i;:::-;2959:11;;;:61;3064:8;;3048:11;;;;:25;;:15;:25::i;:::-;3034:11;;;:39;-1:-1:-1;2755:3:0;;;;:::i;:::-;;;;2728:391;;;;3142:55;3158:38;3166:29;3183:6;:11;;;3166:12;:6;:10;:12::i;:::-;:16;;:29::i;:::-;3158:3;:1;:3::i;:38::-;3142:11;;;;;:15;:55::i;:::-;3128:11;;;:69;3241:54;3264:30;3280:13;:7;;;;:11;:13::i;:::-;3264:15;;;;;;;:11;;;:15;:::i;:30::-;3241:18;3249:5;:9;;;3241:3;:1;:3::i;:54::-;3228:10;;;:67;3384:62;3415:30;3431:13;:7;;;;:11;:13::i;:::-;3415:11;;;;;:15;:30::i;:::-;3384:11;;;;:26;;3400:9;;;;3384:15;:26::i;:62::-;3371:10;;;:75;;;3497:8;;3507:10;;;;3486:44;;3468:70;;3486:44;;3497:8;3507:10;3486:44;;;:::i;3468:70::-;3457:8;;;:81;;;3568:7;;;;3556:19;3548:55;;;;;;;5615:2:4;3548:55:0;;;5597:21:4;5654:2;5634:18;;;5627:30;5693:25;5673:18;;;5666:53;5736:18;;3548:55:0;5413:347:4;3548:55:0;1641:1969;1524:2086;;;:::o;854:95:3:-;901:7;927:15;223:66;927:1;:15;:::i;:::-;920:22;854:95;-1:-1:-1;;854:95:3:o;955:127::-;1013:7;1044:1;1039;:6;;:36;;1074:1;1056:15;1070:1;223:66;1056:15;:::i;:::-;:19;;;;:::i;:::-;1039:36;;;1048:5;1052:1;1048;:5;:::i;:::-;1032:43;955:127;-1:-1:-1;;;955:127:3:o;764:168:0:-;-1:-1:-1;;;;;;;;;;;;;;;;;865:26:0;;;;;;;;6634:25:4;;;841:9:0;;;;865:23;:20;:23;;;;6607:18:4;;865:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;908:17;;;;;;;;;;;;;;;;;764:168;-1:-1:-1;;;;764:168:0:o;3053:415:3:-;-1:-1:-1;;;;;;;;;;;;;;;;;3187:4:3;3181:11;3228:1;3222:8;3212;3205:26;3285:4;3282:1;3278:12;3272:19;3265:4;3255:8;3251:19;3244:48;3333:1;3326:4;3316:8;3312:19;3305:30;3401:4;3398:1;3392:4;3382:8;3376:4;3369:5;3358:48;3348:104;;3436:1;3433;3426:12;3348:104;;3053:415;;;;:::o;2553:494::-;-1:-1:-1;;;;;;;;;;;;;;;;;2694:4:3;2688:11;2735:2;2729:9;2719:8;2712:27;2794:4;2790:2;2786:13;2780:20;2773:4;2763:8;2759:19;2752:49;2848:2;2842:9;2835:4;2825:8;2821:19;2814:38;2907:4;2903:2;2899:13;2893:20;2886:4;2876:8;2872:19;2865:49;2980:4;2977:1;2971:4;2961:8;2955:4;2948:5;2937:48;2927:104;;3015:1;3012;3005:12;623:116;681:7;223:66;717:1;714;707:25;700:32;623:116;-1:-1:-1;;;623:116:3:o;938:168:0:-;-1:-1:-1;;;;;;;;;;;;;;;;;1039:26:0;;;;;;;;6634:25:4;;;1015:9:0;;;;1039:23;:20;:23;;;;6607:18:4;;1039:26:0;6488:177:4;613:145:0;-1:-1:-1;;;;;;;;;;;;;;;;;686:65:0;;;;;;;;698:20;:23;;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;686:65;;;;725:20;:23;;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;686:65;;679:72;613:145;-1:-1:-1;613:145:0:o;3657:127:3:-;3757:4;;3749;;3726;;3749:12;:28;;;;-1:-1:-1;;3773:4:3;;;;;3765;;;:12;;3657:127::o;12046:549::-;12122:24;;:::i;:::-;12322:1;12310:13;;12317:1;12333:256;86:1;12353;:5;12333:256;;;12384:9;12379:200;110:6;12399:5;;12379:200;;;12472:31;12476:6;12483:1;12476:9;;;;;;;:::i;:::-;;;;;12487:1;12489;12487:4;;;;;12500:1;12492:5;12496:1;86;12492:5;:::i;:::-;:9;;;;:::i;:::-;12487:15;;;;;;;:::i;:::-;;;;;12472:3;:31::i;:::-;12441:6;12466:1;12458:5;12462:1;86;12458:5;:::i;:::-;:9;;;;:::i;:::-;12448:20;;12453:1;:14;;12448:1;:20;:::i;:::-;12441:28;;;;;;;:::i;:::-;;;;:62;12533:31;12537:6;12544:1;12537:9;;;;;;;:::i;:::-;;;;;12548:1;12550;12548:4;;12533:31;12521:6;12528:1;12521:9;;;;;;;:::i;:::-;;;;:43;12416:5;12420:1;86;12416:5;:::i;:::-;12406:15;;12411:1;:10;;12406:15;;:::i;:::-;;;12379:200;;;-1:-1:-1;12360:3:3;;;;:::i;:::-;;;;12333:256;;;;12046:549;;;:::o;1088:95::-;1135:7;1161:15;1175:1;223:66;1161:15;:::i;501:116::-;559:7;223:66;595:1;592;585:25;578:32;501:116;-1:-1:-1;;;501:116:3:o;462:145:0:-;-1:-1:-1;;;;;;;;;;;;;;;;;535:65:0;;;;;;;;547:20;:23;;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;535:65;;;;574:20;:23;;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:603:4:-;152:6;160;168;212:9;203:7;199:23;242:4;238:2;234:13;231:33;;;260:1;257;250:12;231:33;296:9;283:23;273:33;;399:4;330:66;326:2;322:75;318:86;315:106;;;417:1;414;407:12;315:106;455:2;444:9;440:18;430:28;;551:3;482:66;478:2;474:75;470:85;467:105;;;568:1;565;558:12;467:105;;606:4;595:9;591:20;581:30;;14:603;;;;;:::o;796:368::-;912:5;935:1;945:213;959:4;956:1;953:11;945:213;;;702:19;;690:32;;778:4;767:16;;;754:30;738:14;;;731:54;1074:4;1098:12;;;;1133:15;;;;979:1;972:9;945:213;;1169:1042;1797:25;;;1783:4;1768:20;;1831:75;1902:2;1887:18;;1879:6;1831:75;:::i;:::-;1915:77;1986:4;1975:9;1971:20;1963:6;1915:77;:::i;:::-;702:19;;2057:4;2042:20;;690:32;778:4;767:16;;754:30;738:14;;;731:54;702:19;;2128:4;2113:20;;690:32;778:4;767:16;;754:30;738:14;;;731:54;702:19;;2199:4;2184:20;;690:32;778:4;767:16;;754:30;738:14;;;731:54;1169:1042;;;;;;;;;:::o;2216:376::-;2340:5;2363:1;2373:213;2387:4;2384:1;2381:11;2373:213;;;702:19;;690:32;;778:4;767:16;;;754:30;738:14;;;731:54;2502:4;2526:12;;;;2561:15;;;;2407:1;2400:9;2373:213;;2597:611;2992:25;;;2979:3;2964:19;;3026:83;3105:2;3090:18;;3082:6;3026:83;:::i;:::-;3118:84;3197:3;3186:9;3182:19;3174:6;3118:84;:::i;:::-;2597:611;;;;;;:::o;3213:184::-;3265:77;3262:1;3255:88;3362:4;3359:1;3352:15;3386:4;3383:1;3376:15;3402:184;3454:77;3451:1;3444:88;3551:4;3548:1;3541:15;3575:4;3572:1;3565:15;3591:195;3630:3;3661:66;3654:5;3651:77;3648:103;;3731:18;;:::i;:::-;-1:-1:-1;3778:1:4;3767:13;;3591:195::o;3791:656::-;3873:6;3926:2;3914:9;3905:7;3901:23;3897:32;3894:52;;;3942:1;3939;3932:12;3894:52;3975:2;3969:9;4017:2;4009:6;4005:15;4086:6;4074:10;4071:22;4050:18;4038:10;4035:34;4032:62;4029:242;;;4127:77;4124:1;4117:88;4228:4;4225:1;4218:15;4256:4;4253:1;4246:15;4029:242;4287:2;4280:22;4326:23;;4311:39;;4411:2;4396:18;;;4383:32;4366:15;;;4359:57;;;;-1:-1:-1;4318:6:4;3791:656;-1:-1:-1;3791:656:4:o;4962:446::-;5257:25;;;5244:3;5229:19;;5291:51;5338:2;5323:18;;5315:6;4882:12;;4870:25;;4944:4;4933:16;;;4927:23;4911:14;;4904:47;4811:146;5291:51;4882:12;;5398:2;5383:18;;4870:25;4944:4;4933:16;;4927:23;4911:14;;;4904:47;5351:51;4811:146;5954:266;5986:1;6012;6002:189;;6047:77;6044:1;6037:88;6148:4;6145:1;6138:15;6176:4;6173:1;6166:15;6002:189;-1:-1:-1;6205:9:4;;5954:266::o;6225:125::-;6265:4;6293:1;6290;6287:8;6284:34;;;6298:18;;:::i;:::-;-1:-1:-1;6335:9:4;;6225:125::o;6355:128::-;6395:3;6426:1;6422:6;6419:1;6416:13;6413:39;;;6432:18;;:::i;:::-;-1:-1:-1;6468:9:4;;6355:128::o;6670:245::-;6749:6;6757;6810:2;6798:9;6789:7;6785:23;6781:32;6778:52;;;6826:1;6823;6816:12;6778:52;-1:-1:-1;;6849:16:4;;6905:2;6890:18;;;6884:25;6849:16;;6884:25;;-1:-1:-1;6670:245:4:o;6920:184::-;6990:6;7043:2;7031:9;7022:7;7018:23;7014:32;7011:52;;;7059:1;7056;7049:12;7011:52;-1:-1:-1;7082:16:4;;6920:184;-1:-1:-1;6920:184:4:o
Swarm Source
ipfs://16104808c532418261a4ee51d08126c04f39883537bf11bcfdd55cbe932cf8e5
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.