diff --git "a/tokenizer.json" "b/tokenizer.json" new file mode 100644--- /dev/null +++ "b/tokenizer.json" @@ -0,0 +1,147086 @@ +{ + "version": "1.0", + "truncation": null, + "padding": null, + "added_tokens": [ + { + "id": 0, + "content": "[PAD]", + "single_word": false, + "lstrip": false, + "rstrip": false, + "normalized": false, + "special": true + }, + { + "id": 1, + "content": "[UNK]", + "single_word": false, + "lstrip": false, + "rstrip": false, + "normalized": false, + "special": true + }, + { + "id": 2, + "content": "[CLS]", + "single_word": false, + "lstrip": false, + "rstrip": false, + "normalized": false, + "special": true + }, + { + "id": 3, + "content": "[SEP]", + "single_word": false, + "lstrip": false, + "rstrip": false, + "normalized": false, + "special": true + }, + { + "id": 4, + "content": "[MASK]", + "single_word": false, + "lstrip": false, + "rstrip": false, + "normalized": false, + "special": true + } + ], + "normalizer": null, + "pre_tokenizer": null, + "post_processor": null, + "decoder": null, + "model": { + "type": "BPE", + "dropout": null, + "unk_token": "[UNK]", + "continuing_subword_prefix": null, + "end_of_word_suffix": null, + "fuse_unk": false, + "byte_fallback": false, + "ignore_merges": false, + "vocab": { + "[PAD]": 0, + "[UNK]": 1, + "[CLS]": 2, + "[SEP]": 3, + "[MASK]": 4, + " ": 5, + "!": 6, + "\"": 7, + "#": 8, + "$": 9, + "%": 10, + "&": 11, + "'": 12, + "(": 13, + ")": 14, + "*": 15, + "+": 16, + ",": 17, + "-": 18, + ".": 19, + "/": 20, + "0": 21, + "1": 22, + "2": 23, + "3": 24, + "4": 25, + "5": 26, + "6": 27, + "7": 28, + "8": 29, + "9": 30, + ":": 31, + ";": 32, + "<": 33, + "=": 34, + ">": 35, + "?": 36, + "@": 37, + "A": 38, + "B": 39, + "C": 40, + "D": 41, + "E": 42, + "F": 43, + "G": 44, + "H": 45, + "I": 46, + "J": 47, + "K": 48, + "L": 49, + "M": 50, + "N": 51, + "O": 52, + "P": 53, + "Q": 54, + "R": 55, + "S": 56, + "T": 57, + "U": 58, + "V": 59, + "W": 60, + "X": 61, + "Y": 62, + "Z": 63, + "[": 64, + "\\": 65, + "]": 66, + "^": 67, + "_": 68, + "`": 69, + "a": 70, + "b": 71, + "c": 72, + "d": 73, + "e": 74, + "f": 75, + "g": 76, + "h": 77, + "i": 78, + "j": 79, + "k": 80, + "l": 81, + "m": 82, + "n": 83, + "o": 84, + "p": 85, + "q": 86, + "r": 87, + "s": 88, + "t": 89, + "u": 90, + "v": 91, + "w": 92, + "x": 93, + "y": 94, + "z": 95, + "{": 96, + "|": 97, + "}": 98, + "~": 99, + " ": 100, + "¡": 101, + "©": 102, + "ª": 103, + "«": 104, + "¬": 105, + "°": 106, + "²": 107, + "´": 108, + "µ": 109, + "º": 110, + "»": 111, + "¼": 112, + "½": 113, + "Å": 114, + "Æ": 115, + "Ç": 116, + "Ð": 117, + "Ñ": 118, + "Ö": 119, + "×": 120, + "Ü": 121, + "ß": 122, + "á": 123, + "ä": 124, + "å": 125, + "æ": 126, + "ç": 127, + "é": 128, + "ê": 129, + "ì": 130, + "ñ": 131, + "ó": 132, + "ö": 133, + "÷": 134, + "ü": 135, + "ÿ": 136, + "Đ": 137, + "ı": 138, + "Ĺ": 139, + "Ǝ": 140, + "ƒ": 141, + "ǝ": 142, + "ɐ": 143, + "ɔ": 144, + "ɯ": 145, + "ɹ": 146, + "ʇ": 147, + "ʎ": 148, + "ʔ": 149, + "ʕ": 150, + "ʖ": 151, + "ʘ": 152, + "ˆ": 153, + "˘": 154, + "˚": 155, + "̚": 156, + "̣": 157, + "̯": 158, + "̿": 159, + "͜": 160, + "͡": 161, + "Γ": 162, + "Σ": 163, + "Φ": 164, + "α": 165, + "δ": 166, + "ε": 167, + "σ": 168, + "φ": 169, + "ω": 170, + "Д": 171, + "щ": 172, + "Ԁ": 173, + "ಠ": 174, + "ಥ": 175, + "෴": 176, + "ฅ": 177, + "ຶ": 178, + "༎": 179, + "ᆺ": 180, + "ᴥ": 181, + " ": 182, + "‍": 183, + "–": 184, + "—": 185, + "‖": 186, + "‘": 187, + "’": 188, + "“": 189, + "”": 190, + "•": 191, + "…": 192, + "‿": 193, + "ⁿ": 194, + "→": 195, + "↓": 196, + "⇒": 197, + "∈": 198, + "√": 199, + "∞": 200, + "∩": 201, + "≈": 202, + "≤": 203, + "≥": 204, + "⊙": 205, + "⌂": 206, + "⌐": 207, + "⌠": 208, + "⌡": 209, + "─": 210, + "━": 211, + "│": 212, + "┃": 213, + "┌": 214, + "┏": 215, + "┐": 216, + "┓": 217, + "└": 218, + "┗": 219, + "┘": 220, + "┛": 221, + "├": 222, + "┣": 223, + "┤": 224, + "┫": 225, + "┬": 226, + "┳": 227, + "┴": 228, + "┼": 229, + "═": 230, + "║": 231, + "╒": 232, + "╓": 233, + "╔": 234, + "╕": 235, + "╖": 236, + "╗": 237, + "╘": 238, + "╙": 239, + "╚": 240, + "╛": 241, + "╜": 242, + "╝": 243, + "╞": 244, + "╟": 245, + "╠": 246, + "╡": 247, + "╢": 248, + "╣": 249, + "╤": 250, + "╥": 251, + "╦": 252, + "╧": 253, + "╨": 254, + "╩": 255, + "╪": 256, + "╫": 257, + "╬": 258, + "╭": 259, + "╮": 260, + "╯": 261, + "╰": 262, + "╱": 263, + "▀": 264, + "▄": 265, + "█": 266, + "▌": 267, + "▐": 268, + "░": 269, + "▒": 270, + "▓": 271, + "◉": 272, + "●": 273, + "◕": 274, + "◡": 275, + "◢": 276, + "◣": 277, + "☰": 278, + "♂": 279, + "♥": 280, + "⚆": 281, + "⚗": 282, + "✓": 283, + "✘": 284, + "✿": 285, + "❤": 286, + "⠀": 287, + "⠁": 288, + "⠂": 289, + "⠃": 290, + "⠄": 291, + "⠅": 292, + "⠆": 293, + "⠇": 294, + "⠈": 295, + "⠉": 296, + "⠊": 297, + "⠋": 298, + "⠌": 299, + "⠍": 300, + "⠎": 301, + "⠏": 302, + "⠐": 303, + "⠑": 304, + "⠒": 305, + "⠓": 306, + "⠔": 307, + "⠕": 308, + "⠖": 309, + "⠗": 310, + "⠘": 311, + "⠙": 312, + "⠚": 313, + "⠛": 314, + "⠝": 315, + "⠞": 316, + "⠟": 317, + "⠠": 318, + "⠡": 319, + "⠤": 320, + "⠥": 321, + "⠨": 322, + "⠩": 323, + "⠫": 324, + "⠬": 325, + "⠯": 326, + "⠰": 327, + "⠲": 328, + "⠳": 329, + "⠴": 330, + "⠶": 331, + "⠷": 332, + "⠸": 333, + "⠹": 334, + "⠺": 335, + "⠻": 336, + "⠼": 337, + "⠽": 338, + "⠾": 339, + "⠿": 340, + "⡀": 341, + "⡁": 342, + "⡄": 343, + "⡅": 344, + "⡆": 345, + "⡇": 346, + "⡈": 347, + "⡉": 348, + "⡌": 349, + "⡎": 350, + "⡏": 351, + "⡖": 352, + "⡗": 353, + "⡘": 354, + "⡛": 355, + "⡜": 356, + "⡝": 357, + "⡞": 358, + "⡟": 359, + "⡠": 360, + "⡡": 361, + "⡢": 362, + "⡤": 363, + "⡥": 364, + "⡦": 365, + "⡧": 366, + "⡩": 367, + "⡬": 368, + "⡭": 369, + "⡯": 370, + "⡰": 371, + "⡲": 372, + "⡳": 373, + "⡴": 374, + "⡵": 375, + "⡷": 376, + "⡹": 377, + "⡺": 378, + "⡻": 379, + "⡼": 380, + "⡽": 381, + "⡾": 382, + "⡿": 383, + "⢀": 384, + "⢄": 385, + "⢆": 386, + "⢇": 387, + "⢈": 388, + "⢊": 389, + "⢋": 390, + "⢍": 391, + "⢎": 392, + "⢏": 393, + "⢓": 394, + "⢔": 395, + "⢗": 396, + "⢘": 397, + "⢛": 398, + "⢜": 399, + "⢞": 400, + "⢟": 401, + "⢠": 402, + "⢡": 403, + "⢣": 404, + "⢤": 405, + "⢥": 406, + "⢦": 407, + "⢧": 408, + "⢪": 409, + "⢫": 410, + "⢮": 411, + "⢯": 412, + "⢰": 413, + "⢱": 414, + "⢲": 415, + "⢳": 416, + "⢶": 417, + "⢷": 418, + "⢸": 419, + "⢹": 420, + "⢺": 421, + "⢻": 422, + "⢽": 423, + "⢾": 424, + "⢿": 425, + "⣀": 426, + "⣁": 427, + "⣄": 428, + "⣅": 429, + "⣆": 430, + "⣇": 431, + "⣈": 432, + "⣉": 433, + "⣊": 434, + "⣋": 435, + "⣌": 436, + "⣍": 437, + "⣎": 438, + "⣏": 439, + "⣒": 440, + "⣕": 441, + "⣖": 442, + "⣗": 443, + "⣙": 444, + "⣛": 445, + "⣜": 446, + "⣝": 447, + "⣞": 448, + "⣟": 449, + "⣠": 450, + "⣡": 451, + "⣢": 452, + "⣤": 453, + "⣥": 454, + "⣦": 455, + "⣧": 456, + "⣨": 457, + "⣩": 458, + "⣪": 459, + "⣫": 460, + "⣬": 461, + "⣭": 462, + "⣮": 463, + "⣯": 464, + "⣰": 465, + "⣱": 466, + "⣲": 467, + "⣳": 468, + "⣴": 469, + "⣵": 470, + "⣶": 471, + "⣷": 472, + "⣸": 473, + "⣹": 474, + "⣻": 475, + "⣼": 476, + "⣽": 477, + "⣾": 478, + "⣿": 479, + "　": 480, + "、": 481, + "。": 482, + "あ": 483, + "��": 484, + "う": 485, + "え": 486, + "お": 487, + "か": 488, + "が": 489, + "き": 490, + "く": 491, + "ぐ": 492, + "け": 493, + "こ": 494, + "ご": 495, + "さ": 496, + "し": 497, + "じ": 498, + "す": 499, + "ず": 500, + "せ": 501, + "ぜ": 502, + "そ": 503, + "た": 504, + "だ": 505, + "ち": 506, + "っ": 507, + "つ": 508, + "て": 509, + "で": 510, + "と": 511, + "ど": 512, + "な": 513, + "に": 514, + "ぬ": 515, + "の": 516, + "は": 517, + "ば": 518, + "ひ": 519, + "び": 520, + "べ": 521, + "ほ": 522, + "ま": 523, + "み": 524, + "む": 525, + "め": 526, + "も": 527, + "や": 528, + "よ": 529, + "ら": 530, + "り": 531, + "る": 532, + "れ": 533, + "ろ": 534, + "わ": 535, + "を": 536, + "ア": 537, + "イ": 538, + "ウ": 539, + "ェ": 540, + "ォ": 541, + "ク": 542, + "コ": 543, + "ジ": 544, + "ス": 545, + "タ": 546, + "ッ": 547, + "デ": 548, + "ト": 549, + "ド": 550, + "バ": 551, + "フ": 552, + "ベ": 553, + "ラ": 554, + "リ": 555, + "ル": 556, + "レ": 557, + "ロ": 558, + "ン": 559, + "ー": 560, + "三": 561, + "上": 562, + "不": 563, + "中": 564, + "争": 565, + "事": 566, + "人": 567, + "今": 568, + "付": 569, + "休": 570, + "伝": 571, + "伸": 572, + "信": 573, + "個": 574, + "全": 575, + "凶": 576, + "分": 577, + "切": 578, + "別": 579, + "利": 580, + "削": 581, + "前": 582, + "力": 583, + "功": 584, + "加": 585, + "努": 586, + "動": 587, + "勝": 588, + "医": 589, + "十": 590, + "取": 591, + "可": 592, + "叶": 593, + "合": 594, + "吉": 595, + "向": 596, + "否": 597, + "告": 598, + "和": 599, + "喜": 600, + "囚": 601, + "回": 602, + "囲": 603, + "執": 604, + "堅": 605, + "報": 606, + "場": 607, + "変": 608, + "多": 609, + "夜": 610, + "大": 611, + "天": 612, + "奏": 613, + "定": 614, + "宝": 615, + "実": 616, + "寿": 617, + "少": 618, + "布": 619, + "師": 620, + "常": 621, + "幸": 622, + "弁": 623, + "当": 624, + "往": 625, + "待": 626, + "後": 627, + "御": 628, + "徳": 629, + "心": 630, + "必": 631, + "快": 632, + "恵": 633, + "愛": 634, + "感": 635, + "成": 636, + "戻": 637, + "所": 638, + "技": 639, + "拒": 640, + "持": 641, + "指": 642, + "数": 643, + "方": 644, + "既": 645, + "早": 646, + "昌": 647, + "時": 648, + "替": 649, + "最": 650, + "有": 651, + "望": 652, + "末": 653, + "来": 654, + "格": 655, + "標": 656, + "機": 657, + "欺": 658, + "止": 659, + "歩": 660, + "歳": 661, + "殿": 662, + "比": 663, + "毘": 664, + "決": 665, + "沙": 666, + "治": 667, + "準": 668, + "無": 669, + "焦": 670, + "独": 671, + "狭": 672, + "环": 673, + "球": 674, + "理": 675, + "用": 676, + "異": 677, + "白": 678, + "益": 679, + "着": 680, + "知": 681, + "神": 682, + "祥": 683, + "福": 684, + "穏": 685, + "範": 686, + "縁": 687, + "老": 688, + "股": 689, + "能": 690, + "自": 691, + "良": 692, + "行": 693, + "術": 694, + "袋": 695, + "装": 696, + "要": 697, + "見": 698, + "言": 699, + "記": 700, + "設": 701, + "許": 702, + "診": 703, + "詐": 704, + "該": 705, + "調": 706, + "諦": 707, + "負": 708, + "財": 709, + "赖": 710, + "転": 711, + "載": 712, + "近": 713, + "返": 714, + "迷": 715, + "追": 716, + "退": 717, + "送": 718, + "進": 719, + "遅": 720, + "過": 721, + "遠": 722, + "選": 723, + "避": 724, + "配": 725, + "酬": 726, + "門": 727, + "防": 728, + "除": 729, + "隆": 730, + "障": 731, + "電": 732, + "驚": 733, + "高": 734, + "黒": 735, + "꒰": 736, + "꒱": 737, + "ꓕ": 738, + "ꓤ": 739, + "ꓵ": 740, + "️": 741, + "ﻌ": 742, + "（": 743, + "）": 744, + "｀": 745, + " ": 746, + " ": 747, + "\\n": 748, + "\\n ": 749, + "re": 750, + "nt": 751, + "er": 752, + "al": 753, + "e ": 754, + "s ": 755, + "en": 756, + "int": 757, + " *": 758, + "to": 759, + "on": 760, + "\\n ": 761, + "th": 762, + "ti": 763, + "ad": 764, + "an": 765, + "in": 766, + "res": 767, + "\\n *": 768, + "dres": 769, + "tu": 770, + "uint": 771, + "addres": 772, + "tion": 773, + ", ": 774, + "ed": 775, + "ou": 776, + "t ": 777, + "ro": 778, + "rn": 779, + "un": 780, + "25": 781, + "256": 782, + "ac": 783, + "//": 784, + "turn": 785, + "de": 786, + "uint256": 787, + "==": 788, + "ount": 789, + "ction": 790, + "return": 791, + "\\n * ": 792, + "fun": 793, + "or": 794, + "function": 795, + "ken": 796, + "es": 797, + ") ": 798, + "address": 799, + "tr": 800, + "ol": 801, + "the ": 802, + "at": 803, + "ow": 804, + "am": 805, + "bl": 806, + "ing": 807, + "all": 808, + "ner": 809, + "pp": 810, + "y ": 811, + ");": 812, + "token": 813, + "ent": 814, + "ern": 815, + "ernal": 816, + "end": 817, + "it": 818, + "\\n ": 819, + "ex": 820, + "is": 821, + "ar": 822, + "**": 823, + "co": 824, + "em": 825, + "ic": 826, + "vi": 827, + "ed ": 828, + "= ": 829, + "amount": 830, + "f ": 831, + "anc": 832, + "ER": 833, + "se": 834, + "qu": 835, + "\\\"": 836, + "ans": 837, + "ender": 838, + "fer": 839, + "\\r": 840, + "val": 841, + "function ": 842, + "rom": 843, + "pu": 844, + "ERC": 845, + "is ": 846, + "ansfer": 847, + "====": 848, + "ver": 849, + ".\\n *": 850, + "ew": 851, + "to ": 852, + "address ": 853, + "a ": 854, + "\\n\\n ": 855, + "qui": 856, + "To": 857, + "// ": 858, + "` ": 859, + "ue": 860, + "uint256 ": 861, + "owner": 862, + "ext": 863, + "as": 864, + "d ": 865, + "rac": 866, + "from": 867, + "cont": 868, + "et": 869, + "ing ": 870, + "ec": 871, + "ri": 872, + "dev": 873, + "/**": 874, + "ool": 875, + "of ": 876, + "00": 877, + "quire": 878, + "@dev": 879, + "\\n *": 880, + "im": 881, + "@dev ": 882, + "us": 883, + "\\n function ": 884, + "\\n }": 885, + "Ow": 886, + "str": 887, + ": ": 888, + "blic": 889, + "ernal ": 890, + "alanc": 891, + "Id": 892, + "public": 893, + "tor": 894, + "yt": 895, + "Token": 896, + "ppro": 897, + ") {": 898, + "abl": 899, + "acc": 900, + "view": 901, + "byt": 902, + "contrac": 903, + "bool": 904, + "dat": 905, + "su": 906, + "el": 907, + "20": 908, + "ma": 909, + "s (": 910, + "mem": 911, + "ip": 912, + "Re": 913, + "no": 914, + "/**\\n * ": 915, + "memor": 916, + " ": 917, + "Owner": 918, + "wa": 919, + "require": 920, + "returns (": 921, + "or ": 922, + "ag": 923, + "returns": 924, + "er ": 925, + ".s": 926, + "account": 927, + "\\n }\\n\\n ": 928, + "Tr": 929, + "call": 930, + "transfer": 931, + "le": 932, + "ee": 933, + "ERC20": 934, + "ms": 935, + "/**\\n * @dev ": 936, + "/\\n function ": 937, + "ul": 938, + "sp": 939, + "ly": 940, + "an ": 941, + "if": 942, + "lo": 943, + "balanc": 944, + "ve": 945, + "////": 946, + ".\\n *\\n * ": 947, + "- ": 948, + "st": 949, + "re ": 950, + "be ": 951, + "si": 952, + "value": 953, + "Transfer": 954, + "msg": 955, + "========": 956, + "ll": 957, + "\\n * ": 958, + "return ": 959, + "dex": 960, + "wap": 961, + "op": 962, + "tokenId": 963, + "dit": 964, + "bytes": 965, + " = ": 966, + "Th": 967, + "tual": 968, + "bu": 969, + "ch": 970, + "ith": 971, + "rtual": 972, + "virtual": 973, + "spender": 974, + ".\\n */\\n function ": 975, + "owanc": 976, + "sh": 977, + "contract": 978, + "internal ": 979, + ",\\n ": 980, + "appro": 981, + "Fee": 982, + "pri": 983, + "o ": 984, + ");\\n ": 985, + "external": 986, + "Ad": 987, + "vat": 988, + "\\n\\n": 989, + "in ": 990, + "privat": 991, + "tal": 992, + "over": 993, + "72": 994, + "public ": 995, + "zer": 996, + "ai": 997, + "es ": 998, + "--": 999, + ") {\\n ": 1000, + "ant": 1001, + "(address ": 1002, + "for ": 1003, + "rec": 1004, + "if ": 1005, + ") internal ": 1006, + "ev": 1007, + "721": 1008, + "not ": 1009, + ". ": 1010, + "um": 1011, + "ator": 1012, + "af": 1013, + "wh": 1014, + "ess": 1015, + "In": 1016, + "view ": 1017, + "index": 1018, + "data": 1019, + "ERC721": 1020, + "32": 1021, + "erf": 1022, + "ation": 1023, + "and ": 1024, + "\\n }\\n\\n /**\\n * @dev ": 1025, + "at ": 1026, + "con": 1027, + "Am": 1028, + "able": 1029, + ".sol": 1030, + "tin": 1031, + "memory": 1032, + "s/": 1033, + "it ": 1034, + "Amount": 1035, + "ting": 1036, + "mo": 1037, + "Co": 1038, + "} ": 1039, + "erfac": 1040, + "allowanc": 1041, + "\\t": 1042, + "event": 1043, + "new": 1044, + "en ": 1045, + "\\n ": 1046, + "Addres": 1047, + "set": 1048, + "ay": 1049, + "\\n * - ": 1050, + "get": 1051, + "@@": 1052, + "ur": 1053, + "di": 1054, + "total": 1055, + ");\\n": 1056, + ";\\n ": 1057, + "Su": 1058, + " to ": 1059, + "s the ": 1060, + "dity": 1061, + "imp": 1062, + "private ": 1063, + "ue ": 1064, + "ient": 1065, + "li": 1066, + "memory ": 1067, + "), ": 1068, + "ship": 1069, + "Cont": 1070, + "Address": 1071, + "oli": 1072, + "ter": 1073, + "overri": 1074, + "..": 1075, + "gn": 1076, + "ei": 1077, + "pro": 1078, + "Supp": 1079, + " of ": 1080, + "\\r\\n": 1081, + "From": 1082, + "from ": 1083, + "ab": 1084, + "virtual ": 1085, + "by ": 1086, + "bytes32": 1087, + "Appro": 1088, + "Ma": 1089, + "add": 1090, + "ck": 1091, + "Return": 1092, + "ve ": 1093, + "require(": 1094, + "true": 1095, + "\\r\\n ": 1096, + "Sender": 1097, + "external ": 1098, + "ror": 1099, + "s:": 1100, + "{\\n ": 1101, + "mint": 1102, + "msgSender": 1103, + "ipient": 1104, + "with": 1105, + ") external ": 1106, + "as ": 1107, + "internal": 1108, + "value ": 1109, + "ce ": 1110, + "that ": 1111, + "eck": 1112, + "All": 1113, + "erator": 1114, + "zero ": 1115, + "////////": 1116, + "recipient": 1117, + "address(": 1118, + "approve": 1119, + "if (": 1120, + "par": 1121, + "interfac": 1122, + "****": 1123, + "string": 1124, + "sender": 1125, + "afe": 1126, + "po": 1127, + "only": 1128, + ", uint256 ": 1129, + "balance": 1130, + "be": 1131, + "cl": 1132, + "string ": 1133, + "For": 1134, + "/ ": 1135, + "cur": 1136, + "ack": 1137, + "rever": 1138, + "_msgSender": 1139, + "age": 1140, + ") public ": 1141, + "Supply": 1142, + "ifi": 1143, + "contract ": 1144, + "Ex": 1145, + "0000": 1146, + "the zero ": 1147, + "TH": 1148, + "sub": 1149, + "pr": 1150, + "air": 1151, + "ment": 1152, + "Of": 1153, + "ke": 1154, + "rent": 1155, + "the zero address": 1156, + "error": 1157, + "================": 1158, + "16": 1159, + "Tokens": 1160, + "ze": 1161, + "ff": 1162, + "red": 1163, + "max": 1164, + "nam": 1165, + "able ": 1166, + "a s": 1167, + "(uint256 ": 1168, + "eng": 1169, + "token ": 1170, + "IERC20": 1171, + "s.": 1172, + "ength": 1173, + "ust ": 1174, + "check": 1175, + "low": 1176, + "this": 1177, + "Call": 1178, + "The ": 1179, + "min": 1180, + "de ": 1181, + "IT": 1182, + "Se": 1183, + "uc": 1184, + "msg.s": 1185, + "msg.sender": 1186, + "balances": 1187, + "0.": 1188, + "iswap": 1189, + "ta": 1190, + "ash": 1191, + "ly ": 1192, + "the": 1193, + ";\\n": 1194, + "ved": 1195, + "Ownership": 1196, + "V2": 1197, + "ot": 1198, + "== ": 1199, + "> ": 1200, + "This ": 1201, + "up": 1202, + "ETH": 1203, + "must ": 1204, + "ate": 1205, + "sy": 1206, + "current": 1207, + "Approval": 1208, + ";\\n\\n": 1209, + "cre": 1210, + "num": 1211, + "burn": 1212, + ", p": 1213, + "on ": 1214, + "----": 1215, + "Balanc": 1216, + "ce": 1217, + "iswapV2": 1218, + "code": 1219, + "atu": 1220, + ");\\n\\n ": 1221, + "ppel": 1222, + "ata": 1223, + "its ": 1224, + "ase": 1225, + "tar": 1226, + "length": 1227, + "operator": 1228, + "name": 1229, + "view returns (": 1230, + "onlyOwner": 1231, + "clu": 1232, + "quidity": 1233, + "with ": 1234, + "mb": 1235, + "ement": 1236, + "}\\n": 1237, + "ist": 1238, + ");\\n\\n ": 1239, + "\\n * - `": 1240, + " is ": 1241, + "mbol": 1242, + "are ": 1243, + "ort ": 1244, + "dity ": 1245, + "] ": 1246, + "symbol": 1247, + " _": 1248, + "ail": 1249, + ");\\n }\\n\\n /**\\n * @dev ": 1250, + "tokens ": 1251, + "ha": 1252, + "sign": 1253, + ", address ": 1254, + ";\\n\\n ": 1255, + "prag": 1256, + ".0": 1257, + "ard": 1258, + "e {": 1259, + "totalSupply": 1260, + "pragm": 1261, + ") {\\n return ": 1262, + "est": 1263, + "resul": 1264, + "bytes ": 1265, + "Returns the ": 1266, + "address(0": 1267, + "Mint": 1268, + "a soli": 1269, + "pragma soli": 1270, + "can": 1271, + "cc": 1272, + "this ": 1273, + "log": 1274, + "contracts/": 1275, + "Op": 1276, + "param": 1277, + "pping": 1278, + "import ": 1279, + "Rou": 1280, + "ock": 1281, + "'s ": 1282, + "Val": 1283, + "(\\n ": 1284, + "\\r\\n ": 1285, + "pa": 1286, + "_balances": 1287, + "lement": 1288, + ", \\\"": 1289, + "struc": 1290, + "swap": 1291, + "can ": 1292, + "ifier": 1293, + "ill": 1294, + "Contrac": 1295, + "0x": 1296, + ").": 1297, + "ut": 1298, + " * ": 1299, + "Rol": 1300, + "not be ": 1301, + "UR": 1302, + "\\n // ": 1303, + "als": 1304, + "ht": 1305, + "pure": 1306, + "Require": 1307, + "Rec": 1308, + "Li": 1309, + ";\\n }\\n\\n /**\\n * @dev ": 1310, + "per": 1311, + "fo": 1312, + "nd": 1313, + "ees": 1314, + "target": 1315, + "allet": 1316, + " ": 1317, + "iti": 1318, + "abi": 1319, + "e(": 1320, + "when ": 1321, + "ERC20: ": 1322, + ".sol\\\"": 1323, + "eth": 1324, + "gr": 1325, + "ty": 1326, + "override ": 1327, + "ting ": 1328, + "icen": 1329, + "mapping": 1330, + "Requirement": 1331, + "essage": 1332, + "ill ": 1333, + "pay": 1334, + "Pair": 1335, + "_owner": 1336, + "/// ": 1337, + "Requirements:": 1338, + " (": 1339, + "bytes32 ": 1340, + "zero": 1341, + "id": 1342, + "indexed": 1343, + "`to": 1344, + "will ": 1345, + "non": 1346, + "interface": 1347, + "bool ": 1348, + "@@@@": 1349, + "Message": 1350, + "pure ": 1351, + "Contract": 1352, + "for": 1353, + "IN": 1354, + "@param": 1355, + "!= ": 1356, + "\\n ": 1357, + "With": 1358, + "Si": 1359, + "4.": 1360, + "Em": 1361, + "Bu": 1362, + "uint ": 1363, + "ccess": 1364, + "emit": 1365, + "dec": 1366, + "own": 1367, + "Balance": 1368, + ") {\\n ": 1369, + "ast": 1370, + "Recei": 1371, + "stant": 1372, + "balanceOf": 1373, + "Licen": 1374, + "mod": 1375, + "Value": 1376, + "h ": 1377, + "Router": 1378, + "import \\\"": 1379, + "0.8": 1380, + "role": 1381, + "_A": 1382, + "IP": 1383, + "dent": 1384, + "il": 1385, + "FF": 1386, + "supp": 1387, + "pure returns (": 1388, + ",\\n uint256 ": 1389, + "open": 1390, + "ed to ": 1391, + "decim": 1392, + "12": 1393, + "constant": 1394, + "ppelin": 1395, + "// S": 1396, + "Wallet": 1397, + "amp": 1398, + "Requirements:\\n *": 1399, + "clud": 1400, + "IERC721": 1401, + "of the ": 1402, + "tim": 1403, + "override": 1404, + "errorMessage": 1405, + ".\\n *\\n * Requirements:\\n *": 1406, + "`from": 1407, + "div": 1408, + "10": 1409, + "indexed ": 1410, + "al ": 1411, + "content": 1412, + "uniswapV2": 1413, + "Allowanc": 1414, + "License": 1415, + "zeppelin": 1416, + "and": 1417, + "s[": 1418, + "\\n // ": 1419, + "cannot be ": 1420, + "Swap": 1421, + "mul": 1422, + "block": 1423, + "_transfer": 1424, + "pragma solidity ": 1425, + "pre": 1426, + "allowance": 1427, + "ature": 1428, + "openzeppelin": 1429, + "URI": 1430, + "tokens": 1431, + "old": 1432, + "view virtual ": 1433, + "Int": 1434, + "address(0), ": 1435, + "MM": 1436, + "Ident": 1437, + ".sol\"": 1438, + "private": 1439, + "\"content": 1440, + "\"content\"": 1441, + "numb": 1442, + "\\n }\\n\\n function ": 1443, + "/contracts/": 1444, + "string memory ": 1445, + "age ": 1446, + "MIT": 1447, + "com": 1448, + "sion": 1449, + " b": 1450, + "\\n *\\n * ": 1451, + "Safe": 1452, + "ra": 1453, + "ed by ": 1454, + "updat": 1455, + " of the ": 1456, + "PD": 1457, + "act": 1458, + "ang": 1459, + "event ": 1460, + "X-": 1461, + "ifier: ": 1462, + "-Ident": 1463, + "License-Ident": 1464, + "License-Identifier: ": 1465, + "PDX-": 1466, + "PDX-License-Identifier: ": 1467, + "Data": 1468, + "] = ": 1469, + ") external view returns (": 1470, + "{\\n ": 1471, + "action": 1472, + "\\n ": 1473, + "uti": 1474, + "// SPDX-License-Identifier: ": 1475, + "Own": 1476, + "\\\");\\n ": 1477, + "safe": 1478, + "ig": 1479, + "165": 1480, + "\"// SPDX-License-Identifier: ": 1481, + "implement": 1482, + "Index": 1483, + "Up": 1484, + ") internal pure returns (": 1485, + "lin": 1486, + "ass": 1487, + "`.": 1488, + "`amount": 1489, + "********": 1490, + "iz": 1491, + "newOwner": 1492, + "itial": 1493, + "noti": 1494, + "Liquidity": 1495, + "ity": 1496, + "(\\n address ": 1497, + "au": 1498, + "star": 1499, + "Count": 1500, + "pl": 1501, + "Total": 1502, + "vail": 1503, + "@noti": 1504, + "EIP": 1505, + "have ": 1506, + "util": 1507, + "allow": 1508, + "////////////////": 1509, + ",\\n address ": 1510, + "ect": 1511, + "}\\n\"": 1512, + "the call": 1513, + ";\\n ": 1514, + "alse": 1515, + "false": 1516, + "send": 1517, + "Math": 1518, + "do": 1519, + ".\\n */\\n function _": 1520, + "cluded": 1521, + "arke": 1522, + "buy": 1523, + "flow": 1524, + "utils/": 1525, + "; ": 1526, + "@notice ": 1527, + "emit ": 1528, + "tokenId` ": 1529, + "Fees": 1530, + "TokenTransfer": 1531, + "On": 1532, + "decimals": 1533, + "._": 1534, + "estamp": 1535, + "hash": 1536, + "returns (bool": 1537, + "ERC165": 1538, + "\\n */\\n function ": 1539, + "encode": 1540, + "ON": 1541, + "red ": 1542, + "lib": 1543, + "uint8": 1544, + "@openzeppelin": 1545, + ";\\n ": 1546, + "result ": 1547, + "success": 1548, + "oth": 1549, + "uncheck": 1550, + "arketing": 1551, + "Un": 1552, + "functionCall": 1553, + "Sign": 1554, + "allowance ": 1555, + "revert ": 1556, + "whic": 1557, + "See {": 1558, + "\"// SPDX-License-Identifier: MIT": 1559, + "tic": 1560, + "0.8.0": 1561, + "tp": 1562, + "ince ": 1563, + "transferFrom": 1564, + "}\\n ": 1565, + "Role": 1566, + "http": 1567, + "Per": 1568, + "_approve": 1569, + "to, ": 1570, + ");\\n\\n /**\\n * @dev ": 1571, + "e the ": 1572, + "etad": 1573, + "of": 1574, + "` cannot be ": 1575, + "\\n\\t": 1576, + "_msgSender(": 1577, + "pragma solidity ^": 1578, + "(_": 1579, + "``": 1580, + "ok": 1581, + "load": 1582, + "\\n// ": 1583, + "s://": 1584, + "abi.": 1585, + "/\\n ": 1586, + "\\n */": 1587, + "https://": 1588, + "+ ": 1589, + "\\r\\n * ": 1590, + "Emits ": 1591, + "overflow": 1592, + "pack": 1593, + "since ": 1594, + "ult": 1595, + "[] ": 1596, + "s, ": 1597, + "pos": 1598, + "` is ": 1599, + "_is": 1600, + "ation ": 1601, + "\\n * @dev ": 1602, + "structor": 1603, + "revert": 1604, + "(\\\"": 1605, + "dead": 1606, + "@openzeppelin/contracts/": 1607, + "Max": 1608, + "vailable ": 1609, + "leg": 1610, + "Out": 1611, + "))": 1612, + "}\\n\\n": 1613, + "ceed": 1614, + "Tim": 1615, + "constructor": 1616, + "bytes memory ": 1617, + "NT": 1618, + "` to ": 1619, + "` cannot be the zero address": 1620, + "allowances": 1621, + "Pro": 1622, + "log(": 1623, + "Str": 1624, + "ID": 1625, + "befo": 1626, + "rar": 1627, + "`, ": 1628, + "Min": 1629, + "\\n */\\n": 1630, + "\\n // ": 1631, + "aus": 1632, + "--------": 1633, + "returndata": 1634, + "data ": 1635, + "istr": 1636, + "Excluded": 1637, + " the ": 1638, + "Id ": 1639, + "deleg": 1640, + "Set": 1641, + "eg": 1642, + "ak": 1643, + "Open": 1644, + "Allowance": 1645, + "abled": 1646, + "amount ": 1647, + "lock": 1648, + "Interfac": 1649, + "embl": 1650, + "@param ": 1651, + "Sel": 1652, + "set ": 1653, + "assembl": 1654, + "rou": 1655, + "18": 1656, + "v4.": 1657, + "can be ": 1658, + "start": 1659, + "sell": 1660, + "\"ERC20: ": 1661, + "0, ": 1662, + ") internal virtual ": 1663, + "than ": 1664, + "AT": 1665, + "If ": 1666, + "s to ": 1667, + "abi.encode": 1668, + "typ": 1669, + "_allowances": 1670, + "Ch": 1671, + "##": 1672, + "../": 1673, + "line": 1674, + "ort": 1675, + "Returns ": 1676, + "....": 1677, + "remo": 1678, + "def": 1679, + "ansaction": 1680, + " != ": 1681, + "col": 1682, + ";\\n\\n/**": 1683, + ">= ": 1684, + "only ": 1685, + "tax": 1686, + "ate ": 1687, + "rol": 1688, + "AS": 1689, + "} event": 1690, + ".\\n * ": 1691, + "Soli": 1692, + " for ": 1693, + ".\\n *\\n * Requirements:\\n *\\n * - `": 1694, + "exist": 1695, + "ast ": 1696, + "librar": 1697, + "SafeMath": 1698, + "ax": 1699, + "Signature": 1700, + "out ": 1701, + "Hash": 1702, + "balance ": 1703, + "new ": 1704, + ".\\n * - `": 1705, + ":= ": 1706, + "\\n\\npragma solidity ^": 1707, + ".\\n *\\n * Emits ": 1708, + "dition": 1709, + "path": 1710, + ".\\n */\\n ": 1711, + "recei": 1712, + ") private ": 1713, + ") public view virtual ": 1714, + "main": 1715, + "point": 1716, + "`amount` ": 1717, + "Ownable": 1718, + "0 ": 1719, + "actor": 1720, + "in the ": 1721, + "OR": 1722, + ".sol\\\";\\n": 1723, + "quant": 1724, + "00000000": 1725, + "ed(": 1726, + "Context": 1727, + "LE": 1728, + "Receiver": 1729, + "String": 1730, + "ap": 1731, + "a {": 1732, + "payable": 1733, + "Tax": 1734, + "liquidity": 1735, + "deadline": 1736, + "transfer ": 1737, + "which ": 1738, + "= _": 1739, + "fee": 1740, + "its": 1741, + "64": 1742, + "uniswapV2Router": 1743, + "RE": 1744, + "].": 1745, + "\\\\": 1746, + "yal": 1747, + "eip": 1748, + "sc": 1749, + "lat": 1750, + "\\r\\n ": 1751, + ". This ": 1752, + "================================": 1753, + " <": 1754, + "\\r\\n function ": 1755, + "Pay": 1756, + "fi": 1757, + "En": 1758, + "entr": 1759, + "cover": 1760, + "etadata": 1761, + "block.": 1762, + "stor": 1763, + "TokenId": 1764, + " == ": 1765, + "ForAll": 1766, + "_isExcluded": 1767, + "Burn": 1768, + "oul": 1769, + "vailable since ": 1770, + "_Available since ": 1771, + "(abi.encode": 1772, + "edValue": 1773, + "is not ": 1774, + "interface ": 1775, + "`tokenId` ": 1776, + "\\r\\n *": 1777, + "using ": 1778, + "Pool": 1779, + "Lo": 1780, + "Not": 1781, + "from, ": 1782, + "reg": 1783, + "before": 1784, + ", uint256 amount": 1785, + "+= ": 1786, + "et ": 1787, + "our": 1788, + "se ": 1789, + "tw": 1790, + ")\\n ": 1791, + "\\n }\\n": 1792, + "ED": 1793, + "sel": 1794, + "int256": 1795, + "ain": 1796, + "reas": 1797, + "itializ": 1798, + "ault": 1799, + "ownership": 1800, + "=> ": 1801, + "override returns (": 1802, + "}.\\n */\\n function ": 1803, + ".sol\\\";\\nimport \\\"": 1804, + "there": 1805, + "emp": 1806, + "__": 1807, + ";\\n\\n/**\\n * @dev ": 1808, + "omin": 1809, + "24": 1810, + "_S": 1811, + "iv": 1812, + "pair": 1813, + "string memory": 1814, + "lot": 1815, + "er of ": 1816, + "ted ": 1817, + "the zero address\"": 1818, + "must be ": 1819, + "* ": 1820, + "ward": 1821, + "approved": 1822, + "result": 1823, + "██": 1824, + "\\n\\t\\t": 1825, + "_symbol": 1826, + "den": 1827, + "{\\n require(": 1828, + "token/": 1829, + "unchecked ": 1830, + "_mint": 1831, + "beforeTokenTransfer": 1832, + "Del": 1833, + ",\\n ": 1834, + "UniswapV2": 1835, + "id ": 1836, + "crease": 1837, + "Sell": 1838, + "{\\n ": 1839, + "any ": 1840, + "ated": 1841, + ") {\\n ": 1842, + "Updat": 1843, + "lea": 1844, + "Ze": 1845, + "Approved": 1846, + "\\n\\npragma solidity ^0.8.0": 1847, + "ess ": 1848, + "timestamp": 1849, + "ffff": 1850, + ") public virtual ": 1851, + "will be ": 1852, + "OpenZe": 1853, + "ice": 1854, + ");\\n ": 1855, + "ominator": 1856, + "\\\");\\n\\n ": 1857, + "OT": 1858, + "@@@@@@@@": 1859, + "chang": 1860, + "number": 1861, + "prod": 1862, + ", amount": 1863, + "tom": 1864, + "e = ": 1865, + "cent": 1866, + "der": 1867, + "support": 1868, + "quantity": 1869, + ");\\n return ": 1870, + "subtr": 1871, + "next": 1872, + "_totalSupply": 1873, + "IERC20-": 1874, + "call ": 1875, + "te": 1876, + ")\\\"": 1877, + "oper": 1878, + "Paus": 1879, + "base": 1880, + "WithSignature": 1881, + "abstr": 1882, + "./": 1883, + "thereum": 1884, + "hold": 1885, + "pres": 1886, + "` cannot be the zero address.\\n * - `": 1887, + "RO": 1888, + "Buy": 1889, + "ppelin ": 1890, + "\\n }\\n}\\n\"": 1891, + "user": 1892, + "ould ": 1893, + "ved ": 1894, + "st ": 1895, + "Counter": 1896, + "p1": 1897, + "\\r\\n }": 1898, + "KK": 1899, + "viou": 1900, + ",\\n address to": 1901, + "` and ": 1902, + "OpenZeppelin ": 1903, + "33": 1904, + "FFFF": 1905, + ", and ": 1906, + "current ": 1907, + "100": 1908, + "add(": 1909, + " ": 1910, + "░░": 1911, + "used ": 1912, + "raw": 1913, + "rc": 1914, + "safeTransfer": 1915, + "\\n /// ": 1916, + "\"@openzeppelin/contracts/": 1917, + "but ": 1918, + "address(this": 1919, + "Address: ": 1920, + "96": 1921, + "AR": 1922, + "_max": 1923, + "grad": 1924, + " {\\n ": 1925, + "IUniswapV2": 1926, + "may ": 1927, + "_balances[": 1928, + "mp": 1929, + ") internal view ": 1930, + "ension": 1931, + ");\\n\\t": 1932, + "previou": 1933, + "FeeOn": 1934, + "OpenZeppelin Contract": 1935, + "_name": 1936, + "dis": 1937, + "(from, ": 1938, + "sto": 1939, + "ecc": 1940, + "eccak": 1941, + "keccak": 1942, + "_value": 1943, + "::": 1944, + "Operator": 1945, + "}.": 1946, + "Received": 1947, + "denominator": 1948, + "p2": 1949, + "\\r\\n }\\r\\n": 1950, + "_to": 1951, + "_isExcludedFrom": 1952, + ";\\n\\nimport \\\"": 1953, + "}\\n\\n\\t": 1954, + ") external": 1955, + ");\\n }\\n\\n function ": 1956, + "ook": 1957, + "vo": 1958, + "address(0), \\\"": 1959, + "keccak256": 1960, + ".sol)": 1961, + "BB": 1962, + "exceed": 1963, + "grant": 1964, + "non-": 1965, + "\\n * ": 1966, + "Con": 1967, + "marketing": 1968, + "Metadata": 1969, + "read": 1970, + "Wh": 1971, + "\"// SPDX-License-Identifier: MIT\\n// ": 1972, + "\\u": 1973, + "\\u00": 1974, + "_beforeTokenTransfer": 1975, + " > ": 1976, + "ati": 1977, + "{\\n\\t\\t": 1978, + "Enabled": 1979, + "&&": 1980, + "uint256) {\\n ": 1981, + "row": 1982, + "MMMM": 1983, + "Log": 1984, + "interfaceId": 1985, + "Rew": 1986, + "error ": 1987, + "() external view returns (": 1988, + "orm": 1989, + "of `": 1990, + "uint amount": 1991, + "}\\n\\n\\tfunction ": 1992, + "aim": 1993, + "calldata": 1994, + "WithSignature(\\\"": 1995, + "));\\n\\t": 1996, + "(abi.encodeWithSignature(\\\"": 1997, + "actory": 1998, + "all ": 1999, + "gen": 2000, + "ref": 2001, + ") internal view {\\n\\t\\t": 2002, + "(abi.encodeWithSignature(\\\"log(": 2003, + "remove": 2004, + ", p0": 2005, + ")\\\", p0": 2006, + "exp": 2007, + "Reward": 2008, + "_t": 2009, + "use": 2010, + "clude": 2011, + ".\\n ": 2012, + "packed": 2013, + "IERC165": 2014, + "ark": 2015, + "_token": 2016, + "vel": 2017, + "][": 2018, + "ase ": 2019, + "}\\n ": 2020, + "has ": 2021, + "ally ": 2022, + "le ": 2023, + "uniswapV2Pair": 2024, + "Reentr": 2025, + "Res": 2026, + "use ": 2027, + ";\\n }\\n\\n ": 2028, + "BIT": 2029, + "the owner": 2030, + "Tx": 2031, + "a {Transfer": 2032, + "ari": 2033, + ", _": 2034, + "imit": 2035, + "man": 2036, + "oun": 2037, + "ZZ": 2038, + ".or": 2039, + "ethereum": 2040, + "AL": 2041, + "`to` ": 2042, + "At": 2043, + "sibl": 2044, + "after": 2045, + "ind": 2046, + "Transferred": 2047, + "storage ": 2048, + "ech": 2049, + " - ": 2050, + "ERC721A": 2051, + "super": 2052, + "numer": 2053, + "me": 2054, + "been ": 2055, + "128": 2056, + "constant ": 2057, + "uint256) {\\n return ": 2058, + "number of ": 2059, + "Enumer": 2060, + "er than ": 2061, + "Solidity": 2062, + "e that ": 2063, + ";\\r\\n": 2064, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contract": 2065, + "3.": 2066, + "_burn": 2067, + ");\\n ": 2068, + "ApprovalForAll": 2069, + "(address owner": 2070, + " and ": 2071, + "(tokenId": 2072, + "rop": 2073, + ") public view virtual override returns (": 2074, + ".\\n *\\n * Requirements:\\n *\\n * - ": 2075, + "Er": 2076, + "`account": 2077, + "act ": 2078, + ");\\r\\n": 2079, + "OwnershipTransferred": 2080, + "more ": 2081, + ");\\n }\\n\\n ": 2082, + ";\\n }\\n\\n function ": 2083, + "Error": 2084, + ",\\n address to,\\n uint256 ": 2085, + "ale": 2086, + "TokensFor": 2087, + "supports": 2088, + "account ": 2089, + "ating ": 2090, + "onlyOwner ": 2091, + "calldata ": 2092, + "Admin": 2093, + "zero, ": 2094, + "supportsInterfac": 2095, + "Payload": 2096, + "mit": 2097, + "`.\\n * - ": 2098, + "block.timestamp": 2099, + "s a ": 2100, + "last": 2101, + "St": 2102, + "an {": 2103, + "src": 2104, + "****************": 2105, + "tion ": 2106, + "Ro": 2107, + ".\\n *\\n * _Available since ": 2108, + "signed ": 2109, + "updated ": 2110, + "), \\\"": 2111, + ".length": 2112, + "assembly ": 2113, + "Mo": 2114, + "ENT": 2115, + "Marketing": 2116, + "MA": 2117, + "(address => ": 2118, + "Num": 2119, + "pool": 2120, + "_send": 2121, + "vent": 2122, + "| ": 2123, + "present": 2124, + "(\\n address from": 2125, + "scri": 2126, + "[] memory ": 2127, + "s are ": 2128, + ".\\n *\\n * Emits a {Transfer": 2129, + ".sol)\\n\\npragma solidity ^0.8.0": 2130, + "@param _": 2131, + "safeTransferFrom": 2132, + "extension": 2133, + "} el": 2134, + ", p1": 2135, + ")\\\", p0, p1": 2136, + "(address indexed ": 2137, + "Transaction": 2138, + "IM": 2139, + "arket": 2140, + "round": 2141, + "must have ": 2142, + "ke ": 2143, + "app": 2144, + "owner, ": 2145, + "LogPayload": 2146, + "_sendLogPayload": 2147, + "erve": 2148, + "pragma solidity": 2149, + "ame ": 2150, + "ed in ": 2151, + "two ": 2152, + "mech": 2153, + "MIN": 2154, + "s-": 2155, + "\\n * `": 2156, + "ION": 2157, + "Sta": 2158, + ") = ": 2159, + ";\\n }\\n\\n /**\\n * @dev See {": 2160, + "ector": 2161, + "subtract": 2162, + "if the ": 2163, + "should ": 2164, + ", address indexed ": 2165, + "(\\n address from,\\n address to,\\n uint256 ": 2166, + "update": 2167, + "uint16": 2168, + "sum": 2169, + "mechan": 2170, + "est ": 2171, + "yp": 2172, + "the caller": 2173, + "mechanis": 2174, + "ject": 2175, + ";\\n\\n // ": 2176, + ");\\r\\n ": 2177, + "E_": 2178, + "last ": 2179, + "we ": 2180, + "address,": 2181, + "put": 2182, + "reward": 2183, + "proof": 2184, + "/**\\n * @notice ": 2185, + "remain": 2186, + "level": 2187, + "p3": 2188, + "'t ": 2189, + "signatu": 2190, + "_amount": 2191, + "27": 2192, + "isi": 2193, + "bytes4": 2194, + ", string memory ": 2195, + "(from, to, ": 2196, + ", p2": 2197, + ")\\\", p0, p1, p2": 2198, + "fees": 2199, + "ne": 2200, + "ffer": 2201, + "(address account": 2202, + "out": 2203, + "Rate": 2204, + ") internal view virtual ": 2205, + "++": 2206, + ",\\r\\n ": 2207, + "yalty": 2208, + "1 ": 2209, + "amount exceed": 2210, + "grade": 2211, + "v3.": 2212, + "tra": 2213, + "ERC721Received": 2214, + "._\\n */\\n function ": 2215, + "draw": 2216, + "dep": 2217, + "(uint256 tokenId": 2218, + "/EIP": 2219, + "Check": 2220, + "\\\\x": 2221, + ").\\n *\\n * ": 2222, + "vid": 2223, + "posi": 2224, + "SS": 2225, + "Pr": 2226, + "allowed": 2227, + "subtractedValue": 2228, + "ren": 2229, + "Au": 2230, + "_AD": 2231, + "Imp": 2232, + "verif": 2233, + "Exact": 2234, + "the\\n * ": 2235, + "one ": 2236, + "sta": 2237, + "later": 2238, + "buffer": 2239, + "es[": 2240, + "Initializ": 2241, + "unchecked {\\n ": 2242, + ".org": 2243, + "es/": 2244, + "spender` ": 2245, + "signature": 2246, + "Timestamp": 2247, + "Recover": 2248, + "Po": 2249, + "t to ": 2250, + "Role(": 2251, + "used": 2252, + "called ": 2253, + "ch ": 2254, + "``'s ": 2255, + "down": 2256, + ">> ": 2257, + "fir": 2258, + "approve ": 2259, + "addr": 2260, + ".\\n *\\n * ": 2261, + " `": 2262, + "(address(0), ": 2263, + "creaseAllowance": 2264, + "er is not ": 2265, + "ing the ": 2266, + "fail": 2267, + "amount of ": 2268, + " ": 2269, + "multi": 2270, + "xref": 2271, + "using": 2272, + "implementation": 2273, + "ffic": 2274, + ";\\n }\\n\\n /**\\n * @dev Returns the ": 2275, + "afterTokenTransfer": 2276, + "mut": 2277, + ",,": 2278, + "_in": 2279, + "Implement": 2280, + "back": 2281, + ";\\n ": 2282, + "ading": 2283, + "OO": 2284, + "ker": 2285, + "soli": 2286, + "`.\\n */\\n function ": 2287, + "oc": 2288, + "returns (bool) {\\n ": 2289, + "Eth": 2290, + "at le": 2291, + " != address(0), \\\"": 2292, + "; // ": 2293, + "ead": 2294, + "fe": 2295, + "WETH": 2296, + "ication": 2297, + "Deleg": 2298, + "an {Approval": 2299, + ".\\n ": 2300, + "0) {\\n ": 2301, + "iven ": 2302, + "not": 2303, + ",\\n * ": 2304, + "ow ": 2305, + "bytes memory": 2306, + "ether ": 2307, + ") internal view {\\n\\t\\t_sendLogPayload": 2308, + ") internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(": 2309, + "Market": 2310, + "del": 2311, + " ": 2312, + ", bool ": 2313, + "));\\n\\t}\\n\\n\\tfunction ": 2314, + "s `amount` ": 2315, + "for the ": 2316, + "when the ": 2317, + "possibl": 2318, + "Set ": 2319, + "ity ": 2320, + "target, ": 2321, + ") internal view returns (": 2322, + "----------------": 2323, + "uint256 private ": 2324, + "baseURI": 2325, + "amount exceeds ": 2326, + "30": 2327, + "}\\n\\n ": 2328, + "assembly": 2329, + "<= ": 2330, + "approval": 2331, + "ERC20/": 2332, + "_tax": 2333, + "burned": 2334, + "EX": 2335, + "`.\\n *\\n * ": 2336, + "ght": 2337, + "55": 2338, + "vari": 2339, + "try": 2340, + "ifier ": 2341, + "token/ERC20/": 2342, + "EC": 2343, + "fficient": 2344, + ".\\n ": 2345, + "valid ": 2346, + "Pack": 2347, + "\\n *\\n * ": 2348, + "`owner": 2349, + "\\n ": 2350, + "ata ": 2351, + "rect": 2352, + "tokensFor": 2353, + "bytes memory data": 2354, + "tic ": 2355, + "modifier": 2356, + "edi": 2357, + "given ": 2358, + "previous": 2359, + ";\\n\\n ": 2360, + "(uint256 a": 2361, + "_decimals": 2362, + "gas ": 2363, + "} event.\\n */\\n function ": 2364, + "mapping(address => ": 2365, + "Byt": 2366, + "e.": 2367, + "act contract ": 2368, + "< ": 2369, + "reserve": 2370, + "ber": 2371, + ";\\n\\n /**\\n * @dev ": 2372, + ".\\n *\\n * _Available since v3.": 2373, + "Dev": 2374, + "De": 2375, + "list": 2376, + "(1": 2377, + "ANT": 2378, + "SafeMath: ": 2379, + "spec": 2380, + "startTokenId": 2381, + "_T": 2382, + "abstract contract ": 2383, + "()": 2384, + "WithValue": 2385, + "functionCallWithValue": 2386, + "library ": 2387, + "; i": 2388, + "============": 2389, + "ile ": 2390, + "gener": 2391, + "transaction": 2392, + ";\\n }\\n ": 2393, + ");\\n\\n /**\\n * @dev Returns the ": 2394, + "(bool ": 2395, + "isContract": 2396, + "unchecked": 2397, + "fin": 2398, + "access": 2399, + "DRE": 2400, + "Us": 2401, + "get ": 2402, + "ext ": 2403, + "}\\n }\\n\\n /**\\n * @dev ": 2404, + "ese ": 2405, + "lection": 2406, + "indic": 2407, + "receiver": 2408, + "For ": 2409, + "ard ": 2410, + "S/": 2411, + "owner ": 2412, + ".\\n */\\n": 2413, + "To ": 2414, + "19": 2415, + "ER_": 2416, + "loy": 2417, + "And": 2418, + "signature ": 2419, + "registr": 2420, + "pping ": 2421, + "eip-": 2422, + "holder": 2423, + "/EIPS/": 2424, + "/EIPS/eip-": 2425, + "se {": 2426, + "////////////////////////////////": 2427, + "string,": 2428, + ");\\n _": 2429, + "ethereum.org": 2430, + "s.ethereum.org": 2431, + "https://eip": 2432, + "s.ethereum.org/EIPS/eip-": 2433, + "https://eips.ethereum.org/EIPS/eip-": 2434, + "msg.": 2435, + ", uint256 b": 2436, + "`]": 2437, + "supply": 2438, + "NOT": 2439, + "tokenAmount": 2440, + "mis": 2441, + "pt": 2442, + "bool,": 2443, + "else": 2444, + "============================": 2445, + "\\r\\n ": 2446, + "integ": 2447, + ", p3": 2448, + ")\\\", p0, p1, p2, p3": 2449, + "Ac": 2450, + "DRESS": 2451, + "_tTotal": 2452, + "struct ": 2453, + "Enumerable": 2454, + "erform": 2455, + "(uint256 a, uint256 b": 2456, + "(owner, ": 2457, + "temp": 2458, + "\\n ": 2459, + ") {\\n require(": 2460, + "setApprovalForAll": 2461, + "26": 2462, + "that is ": 2463, + "amountETH": 2464, + "was ": 2465, + "s for ": 2466, + "============================================================": 2467, + "total ": 2468, + "tore": 2469, + "reat": 2470, + "cor": 2471, + "count": 2472, + "Allow": 2473, + "type(": 2474, + "deploy": 2475, + "TxAmount": 2476, + "sub(": 2477, + "oth ": 2478, + "IERC721Receiver": 2479, + "} else {": 2480, + "project": 2481, + "........": 2482, + "Emit": 2483, + "\\r\\n /**": 2484, + "ues": 2485, + "inver": 2486, + "valid": 2487, + "Qu": 2488, + "level ": 2489, + "functions ": 2490, + "stand": 2491, + "delegat": 2492, + "=============================================================": 2493, + "dig": 2494, + ");\\n }\\n\\n /**\\n * @dev S": 2495, + "arg": 2496, + "PO": 2497, + "size": 2498, + " ": 2499, + "Time": 2500, + "fl": 2501, + "ray": 2502, + "\\\");\\n require(": 2503, + ")\\n ": 2504, + ";\\r\\n ": 2505, + "Access": 2506, + "Emitted ": 2507, + ".com": 2508, + "without ": 2509, + "&& ": 2510, + "sol": 2511, + "amountToken": 2512, + "mar": 2513, + "\\n *": 2514, + "immut": 2515, + "p0": 2516, + "our ": 2517, + "[`": 2518, + "code ": 2519, + ") internal virtual {\\n ": 2520, + "to, uint256 ": 2521, + "Solidity's ": 2522, + "then ": 2523, + ") / ": 2524, + "000": 2525, + "indicating ": 2526, + "version": 2527, + "success, ": 2528, + "SA": 2529, + "of a ": 2530, + "ST": 2531, + "tive": 2532, + "admin": 2533, + "`. ": 2534, + "Control": 2535, + "packed ": 2536, + "are": 2537, + "Router0": 2538, + "transfer to ": 2539, + "ter ": 2540, + ");\\n function ": 2541, + "Slot": 2542, + "cludeFrom": 2543, + ")\\n ": 2544, + "{approve": 2545, + "reverting ": 2546, + "meth": 2547, + "0.8.": 2548, + "true ": 2549, + ".sol\\\";\\n\\n/**\\n * @dev ": 2550, + "ou ": 2551, + "ic ": 2552, + "/// @notice ": 2553, + " + ": 2554, + "_from": 2555, + "modul": 2556, + "erk": 2557, + "imum": 2558, + "We ": 2559, + "es not ": 2560, + "tokens from ": 2561, + "represent": 2562, + "no ": 2563, + ".\\r\\n *": 2564, + "ach": 2565, + "11": 2566, + "() ": 2567, + "paused": 2568, + "onERC721Received": 2569, + " := ": 2570, + "_ADDRESS": 2571, + "address(0)": 2572, + "slot": 2573, + "ERC721: ": 2574, + "metho": 2575, + "divisi": 2576, + "emit Transfer": 2577, + ") public virtual override ": 2578, + "selector": 2579, + "Add": 2580, + "Maker": 2581, + " from ": 2582, + "Non": 2583, + "s\\n * ": 2584, + "_r": 2585, + "s = ": 2586, + "_set": 2587, + "p0, ": 2588, + "@return ": 2589, + "MarketMaker": 2590, + "MarketMakerPair": 2591, + "atedMarketMakerPair": 2592, + "tomatedMarketMakerPair": 2593, + "IUniswapV2Router0": 2594, + "if (value ": 2595, + "It ": 2596, + "io": 2597, + "Solidity ": 2598, + "verify": 2599, + " bits": 2600, + "tocol": 2601, + "whether ": 2602, + "library": 2603, + "orting": 2604, + "sufficient": 2605, + "swapExact": 2606, + "\\n //": 2607, + "IC": 2608, + "Zer": 2609, + "\\n // ": 2610, + "ated ": 2611, + "exec": 2612, + "_afterTokenTransfer": 2613, + "recover": 2614, + "`value": 2615, + "call to ": 2616, + "_transferOwnership": 2617, + "atch": 2618, + "auth": 2619, + "Info": 2620, + "Drop": 2621, + "minted ": 2622, + "####": 2623, + "default": 2624, + "ibu": 2625, + "FeeOnTransfer": 2626, + "\\r\\n /**\\r\\n * ": 2627, + "EN": 2628, + "Supporting": 2629, + "SupportingFeeOnTransfer": 2630, + "SupportingFeeOnTransferTokens": 2631, + "om": 2632, + "owned by ": 2633, + "AccessControl": 2634, + "wor": 2635, + "lot ": 2636, + ".com/": 2637, + "39": 2638, + "RA": 2639, + "ing\\n * ": 2640, + ") internal view virtual returns (": 2641, + "less ": 2642, + "(value": 2643, + "approved ": 2644, + "chain": 2645, + "Price": 2646, + "extensions/": 2647, + "supportsInterface(": 2648, + "about ": 2649, + "name_": 2650, + "constant _": 2651, + "s\"": 2652, + "revert reas": 2653, + "defin": 2654, + "addition": 2655, + "Typ": 2656, + "interfaceId ": 2657, + "fit ": 2658, + "ection": 2659, + "ilte": 2660, + "_msgSender()": 2661, + "them": 2662, + " > 0": 2663, + ", uint ": 2664, + "min ": 2665, + "der ": 2666, + "amounts": 2667, + "Base": 2668, + "unsigned ": 2669, + "amountOut": 2670, + "vok": 2671, + "? ": 2672, + " = _": 2673, + "incre": 2674, + ") {\\r\\n ": 2675, + "POS": 2676, + "Solidity's `": 2677, + "symbol_": 2678, + "/\\r\\n function ": 2679, + "Ownable: ": 2680, + "type": 2681, + "TotalFees": 2682, + "ame as ": 2683, + "s(": 2684, + "withdraw": 2685, + "ROLE": 2686, + "gu": 2687, + "currentAllowanc": 2688, + ");\\n}\\n\"": 2689, + "ful": 2690, + "uint256 public ": 2691, + "they ": 2692, + "claim": 2693, + " < ": 2694, + "` and `to` ": 2695, + "` and `to` are ": 2696, + "ffffffff": 2697, + "ves": 2698, + "ond": 2699, + "Chang": 2700, + ") revert ": 2701, + ") internal pure returns (uint256) {\\n ": 2702, + " {\\n /**\\n * @dev ": 2703, + "packedOwnership": 2704, + "Reentrant": 2705, + "alread": 2706, + "transferred ": 2707, + "low-": 2708, + "mechanism": 2709, + "into ": 2710, + "ere ": 2711, + "trading": 2712, + "88": 2713, + "_address": 2714, + "s v4.": 2715, + "gner": 2716, + "ub": 2717, + "mess": 2718, + "delet": 2719, + "alc": 2720, + "addedValue": 2721, + "_get": 2722, + "` is zero, ": 2723, + "implement ": 2724, + "ar ": 2725, + "perform": 2726, + "these ": 2727, + "eith": 2728, + "y, ": 2729, + "the current ": 2730, + " ": 2731, + "Uint": 2732, + ".\\n */\\n event ": 2733, + "mload": 2734, + "nonReentrant": 2735, + "decre": 2736, + "uint64": 2737, + "vert": 2738, + "../../": 2739, + "98": 2740, + "token ID": 2741, + "currentIndex": 2742, + "IMP": 2743, + "];\\n ": 2744, + "tokenB": 2745, + "Percent": 2746, + "address-": 2747, + "ame as {": 2748, + "currentAllowance": 2749, + "unsigned integ": 2750, + "ownerOf": 2751, + "first ": 2752, + "ent to ": 2753, + "put ": 2754, + "(msg.sender": 2755, + "-address-": 2756, + "ERC2": 2757, + "} or ": 2758, + "condition": 2759, + "\"SafeMath: ": 2760, + "-}": 2761, + "_isExcludedFromFee": 2762, + "xref-": 2763, + "ame as {xref-": 2764, + "-}[`": 2765, + ", s": 2766, + "Upgrade": 2767, + "_buy": 2768, + "os": 2769, + "already ": 2770, + "Par": 2771, + "modifier ": 2772, + "either ": 2773, + "nap": 2774, + "account (": 2775, + "at least ": 2776, + "Be": 2777, + "ong": 2778, + "n't ": 2779, + "_msgSender(), ": 2780, + "traData": 2781, + "solidity": 2782, + "ing a ": 2783, + "Delegate": 2784, + "failed": 2785, + "LiquidityFee": 2786, + "(address spender": 2787, + "} event ": 2788, + "fig": 2789, + "way ": 2790, + "bot": 2791, + "` operator": 2792, + "part to ": 2793, + "ASK": 2794, + "Counterpart to ": 2795, + "gh ": 2796, + "1 (": 2797, + "napsh": 2798, + "forma": 2799, + "istribu": 2800, + ");\\n }\\n\\n /**\\n * @dev Same as {xref-": 2801, + "Hook": 2802, + "ecaus": 2803, + "Implementation": 2804, + "Or": 2805, + "factory": 2806, + "MASK": 2807, + "- `": 2808, + "operation ": 2809, + ";\\r\\n }\\r\\n": 2810, + ";\\n }\\n\\n /**\\n * @dev See {IERC20-": 2811, + "by": 2812, + "ers": 2813, + "Reg": 2814, + "Permit": 2815, + "MAX": 2816, + "\\r\\n /**\\r\\n * @dev ": 2817, + "ERC20 ": 2818, + "Balance ": 2819, + "PER": 2820, + "es the ": 2821, + "Owned": 2822, + ".\\n *\\n * This ": 2823, + "ery": 2824, + "Block": 2825, + "itel": 2826, + "`to`.\\n * - ": 2827, + ") (": 2828, + "enabled": 2829, + "plac": 2830, + "e. ": 2831, + ", \\\"Address: ": 2832, + "\\n ) external ": 2833, + "quival": 2834, + "ECD": 2835, + "message ": 2836, + "FT": 2837, + "() external ": 2838, + "inter": 2839, + "Zero": 2840, + "ECDSA": 2841, + ", it ": 2842, + "isApproved": 2843, + "Address-": 2844, + "\"ERC20: transfer ": 2845, + " != address(0), \\\"ERC20: ": 2846, + "DE": 2847, + ";\\n emit ": 2848, + "price": 2849, + "IUniswapV2Router02": 2850, + "Last": 2851, + "excludeFrom": 2852, + "great": 2853, + "\\r\\n ": 2854, + "(account": 2855, + "last updated ": 2856, + "s (last updated ": 2857, + "s (last updated v4.": 2858, + "-address-bytes": 2859, + "(\\n address from,\\n address to,\\n uint256 tokenId": 2860, + "while ": 2861, + "tokenId ": 2862, + "gas": 2863, + "\\n\\n /**\\n * @dev ": 2864, + "p3) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(": 2865, + "nored": 2866, + "other ": 2867, + "(uint256 value": 2868, + "((": 2869, + "when": 2870, + ".0) (": 2871, + "lateral": 2872, + "hook": 2873, + ")\\\", p0, p1, p2, p3));\\n\\t}\\n\\n\\tfunction ": 2874, + "Supply ": 2875, + "_check": 2876, + "`role": 2877, + "xy": 2878, + ");\\n }\\n\\n /**\\n * @dev Returns the ": 2879, + "Returns true ": 2880, + "();\\n ": 2881, + "ach ": 2882, + "utils/Context": 2883, + "(from, to, tokenId": 2884, + "int256 ": 2885, + "array": 2886, + "result += ": 2887, + "amountIn": 2888, + "only be ": 2889, + "bytes4 ": 2890, + "uint8 ": 2891, + "from the ": 2892, + "percent": 2893, + "which": 2894, + "Royalty": 2895, + "Size": 2896, + ");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-": 2897, + "asset": 2898, + "afe ": 2899, + "ob": 2900, + "prevent": 2901, + "Counterpart to Solidity's `": 2902, + "MaxTransaction": 2903, + "onlyOwner {\\n ": 2904, + "this function ": 2905, + "2^": 2906, + "tern": 2907, + " in ": 2908, + "struct": 2909, + "Cl": 2910, + "e of the ": 2911, + "Invalid": 2912, + "renoun": 2913, + "50": 2914, + "as a ": 2915, + "also ": 2916, + "Fe": 2917, + "subscri": 2918, + "T_": 2919, + "other": 2920, + "msg.data": 2921, + "eri": 2922, + "36": 2923, + "\\u003": 2924, + "etadata ": 2925, + "r ": 2926, + "assembly {": 2927, + "greater than ": 2928, + ";\\n }\\n ": 2929, + "low-level ": 2930, + "set._": 2931, + "doc": 2932, + "{\\r\\n ": 2933, + "Factory": 2934, + "quivalent to ": 2935, + "ask": 2936, + "_spender": 2937, + "key": 2938, + "FFFFFFFF": 2939, + "ASH": 2940, + "ollow": 2941, + "address owner": 2942, + "Te": 2943, + "dst": 2944, + "KKKK": 2945, + "follow": 2946, + "|| ": 2947, + "Col": 2948, + "712": 2949, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.": 2950, + "s that ": 2951, + "required ": 2952, + ");\\n\\n // ": 2953, + "Length": 2954, + "(a": 2955, + "ge": 2956, + "rit": 2957, + "`from` to ": 2958, + "0000000000000000": 2959, + "AU": 2960, + "() public view virtual override returns (": 2961, + "ir": 2962, + "addLiquidity": 2963, + "ces": 2964, + "Bytes": 2965, + "Team": 2966, + "safeMint": 2967, + "_red": 2968, + "Sha": 2969, + "create": 2970, + "with the ": 2971, + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"": 2972, + "uint32": 2973, + "to be ": 2974, + "operation": 2975, + "BITMASK": 2976, + "2**": 2977, + "_total": 2978, + "parator": 2979, + "gith": 2980, + "s[tokenId": 2981, + "When ": 2982, + "github": 2983, + "does not ": 2984, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.": 2985, + "Cast": 2986, + "_N": 2987, + "Updated": 2988, + "BITPOS": 2989, + "ZZZZ": 2990, + "Lock": 2991, + ") internal returns (": 2992, + "result = ": 2993, + "such ": 2994, + "ist ": 2995, + "ty ": 2996, + "[] calldata ": 2997, + "swapExactTokensFor": 2998, + "input ": 2999, + "(bytes32 ": 3000, + "Limit": 3001, + "tokenA": 3002, + "Round": 3003, + "4.1 (": 3004, + "caller is not ": 3005, + "number of tokens ": 3006, + "aul": 3007, + "[owner": 3008, + "`spender` ": 3009, + ");\\n return true": 3010, + "ot ": 3011, + "Minter": 3012, + "ORT": 3013, + "Emitted when ": 3014, + "as the ": 3015, + ");\\n }\\n}\\n\"": 3016, + "} or {": 3017, + ",\\n ": 3018, + "e is ": 3019, + "ound": 3020, + "HASH": 3021, + "includ": 3022, + "signer": 3023, + "inst": 3024, + "ending": 3025, + "multipl": 3026, + "(address owner, address ": 3027, + ") internal virtual {\\n require(": 3028, + "@@@@@@@@@@@@@@@@": 3029, + "ecode": 3030, + "Address ": 3031, + "payable ": 3032, + "Token ": 3033, + "if (!": 3034, + ",\\n ": 3035, + "insufficient": 3036, + "Wei": 3037, + ");\\n\\n function ": 3038, + "PL": 3039, + "has": 3040, + "{IERC20-": 3041, + "░░░░": 3042, + "\\u0027": 3043, + "contracts.": 3044, + "(0x": 3045, + ", bytes32 ": 3046, + "40": 3047, + "verifyCall": 3048, + "56": 3049, + "to the ": 3050, + "two unsigned integ": 3051, + "rn ": 3052, + "}\\r\\n": 3053, + "uint,": 3054, + "string memory) {\\n return ": 3055, + "initial": 3056, + "does": 3057, + ".\\n *\\n * Emits an {Approval": 3058, + "ownership ": 3059, + "rt": 3060, + "thei": 3061, + "mstore": 3062, + "informa": 3063, + "_balances[account": 3064, + "Result": 3065, + "AD": 3066, + "Checkpoint": 3067, + "BBBB": 3068, + "e.g": 3069, + " = 0": 3070, + "method ": 3071, + "renounce": 3072, + "requ": 3073, + "values": 3074, + "ATOR": 3075, + "napshot": 3076, + "admin ": 3077, + "ERC721/": 3078, + "RecoverError": 3079, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (": 3080, + "_data": 3081, + "_C": 3082, + "cast": 3083, + "mak": 3084, + "execu": 3085, + "invalid ": 3086, + "`from``'s ": 3087, + "can be used ": 3088, + "github.com/": 3089, + "writ": 3090, + "_isExcludedFromFees": 3091, + "cod": 3092, + "/// @dev ": 3093, + "IMPORT": 3094, + "IMPORTANT": 3095, + "remaining ": 3096, + "aDrop": 3097, + ") internal returns (bytes memory": 3098, + "ault ": 3099, + "⠀⠀": 3100, + ". O": 3101, + "} and ": 3102, + "taxAmount": 3103, + "from the zero address\"": 3104, + ".\\n *\\n * Emits a {Transfer} event.\\n */\\n function ": 3105, + "otes": 3106, + "exists": 3107, + "verifyCallResult": 3108, + "direct": 3109, + "the caller ": 3110, + "Gu": 3111, + "amount exceeds balance": 3112, + ") external returns (bool": 3113, + "called by ": 3114, + "_maxTxAmount": 3115, + "constructor(": 3116, + "Minted": 3117, + "variant": 3118, + "erkle": 3119, + "revert reason ": 3120, + "ased ": 3121, + ",\\n string memory ": 3122, + "igh": 3123, + "\"ev": 3124, + "\"evm": 3125, + "transferOwnership": 3126, + "functionCall`]": 3127, + "functionCall-address-bytes": 3128, + "-}[`functionCall`]": 3129, + "List": 3130, + "(target, ": 3131, + "which is ": 3132, + "alcul": 3133, + "isApprovedForAll": 3134, + "Claim": 3135, + "\"contracts/": 3136, + "https://github.com/": 3137, + "lp": 3138, + "each ": 3139, + "izer": 3140, + ") {\\n return _": 3141, + "registrant": 3142, + "(_msgSender(), ": 3143, + "IERC721-": 3144, + "miti": 3145, + ", \\\"ERC20: ": 3146, + "abstract": 3147, + "token/ERC721/": 3148, + "TokenBalance": 3149, + ";\\n uint256 ": 3150, + "_D": 3151, + "swapTokensFor": 3152, + "have been ": 3153, + ") external view returns (uint256": 3154, + "auto": 3155, + "disable": 3156, + "royal": 3157, + "delegate ": 3158, + "AC": 3159, + "}\\n\\n ": 3160, + "Query": 3161, + "lib/": 3162, + "downcast": 3163, + ");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes": 3164, + "via ": 3165, + "stake": 3166, + "Liqui": 3167, + "ever": 3168, + "MMMMMMMM": 3169, + "user ": 3170, + "boole": 3171, + "/// @": 3172, + "Reentranc": 3173, + "$$": 3174, + ", the ": 3175, + "initializ": 3176, + "less than ": 3177, + "Registr": 3178, + "A ": 3179, + "Note that ": 3180, + "E: ": 3181, + "uint96": 3182, + "Pu": 3183, + "ect ": 3184, + "0.6": 3185, + "ecause ": 3186, + "itelist": 3187, + "vide": 3188, + "their ": 3189, + "`from` to `to": 3190, + ".\"": 3191, + "lication": 3192, + "\\\");\\n return ": 3193, + "4c": 3194, + "Rem": 3195, + "supply ": 3196, + "balance of ": 3197, + "you ": 3198, + "3333": 3199, + "77": 3200, + ");\\r\\n }\\r\\n": 3201, + "dur": 3202, + "inSwap": 3203, + "limit": 3204, + "let ": 3205, + "inverse ": 3206, + "amount of tokens ": 3207, + "||": 3208, + "return (": 3209, + "larg": 3210, + "up ": 3211, + "NOTE: ": 3212, + "bit ": 3213, + "TransferAmount": 3214, + "\\n /// @param ": 3215, + "████": 3216, + "available ": 3217, + "on the ": 3218, + "TokensAt": 3219, + "take": 3220, + "112": 3221, + "suc": 3222, + "by the ": 3223, + "spender, ": 3224, + "EE": 3225, + "mall": 3226, + "ed = ": 3227, + "NFT": 3228, + "posit": 3229, + "division ": 3230, + "maximum": 3231, + "_tokenId": 3232, + "Can": 3233, + "s.\\n *\\n * ": 3234, + "Mul": 3235, + ")\\n {\\n ": 3236, + "succeed": 3237, + ") internal {\\n ": 3238, + "10000": 3239, + "Rep": 3240, + "OperatorF": 3241, + "transferred to ": 3242, + "_currentIndex": 3243, + "\\n * ": 3244, + ", 0x": 3245, + "like ": 3246, + " to be ": 3247, + "maxWallet": 3248, + "immutable ": 3249, + " overflow": 3250, + "\\n * @param ": 3251, + "mitig": 3252, + "empt": 3253, + ">>= ": 3254, + "ired": 3255, + "allback": 3256, + "storage": 3257, + "Fun": 3258, + "we": 3259, + "▓▓": 3260, + "possible ": 3261, + "e.g. ": 3262, + "TokensAtAmount": 3263, + ";\\n }\\n}\\n\"": 3264, + ",\\n bytes32 ": 3265, + "`operator": 3266, + ", which ": 3267, + "before ": 3268, + "`value` ": 3269, + "`target": 3270, + "currentAllowance ": 3271, + "Public": 3272, + "ix": 3273, + "the zero address\\\");\\n\\n ": 3274, + "zero\"": 3275, + "an address ": 3276, + "1;\\n ": 3277, + "access/": 3278, + "instead": 3279, + "ers, ": 3280, + "ize": 3281, + "qrt": 3282, + "MarketingFee": 3283, + "Man": 3284, + "Over": 3285, + "order": 3286, + "Allowed": 3287, + "on\\n * ": 3288, + "interfaces/": 3289, + "string private ": 3290, + "intro": 3291, + "Returns a ": 3292, + "specif": 3293, + "amount\\n ": 3294, + "a contract": 3295, + "swapEnabled": 3296, + "i]": 3297, + "\\n // - `": 3298, + "Packed": 3299, + "35": 3300, + "s of ": 3301, + "transferred": 3302, + "CI": 3303, + "contain": 3304, + "there ": 3305, + "revert(": 3306, + "\"ERC20: approve ": 3307, + "tokenURI": 3308, + "cannot ": 3309, + "][spender": 3310, + "spection": 3311, + "tokenId` must ": 3312, + "voke": 3313, + "stak": 3314, + ".sol\\\";\\nimport \\\"./": 3315, + "`tokenId` token": 3316, + "Hex": 3317, + "uint256[] memory ": 3318, + "boolean ": 3319, + "_ ": 3320, + "ain ": 3321, + "introspection": 3322, + ");\\n require(": 3323, + "introspection/": 3324, + "AP": 3325, + "your ": 3326, + "toHex": 3327, + "toHexString": 3328, + "option": 3329, + "application": 3330, + "== 0": 3331, + "Strings": 3332, + "s `amount` tokens from ": 3333, + "for (uint256 ": 3334, + "ves ": 3335, + "ree ": 3336, + "spend": 3337, + "tAmount": 3338, + "}, ": 3339, + "Cha": 3340, + "swa": 3341, + "IERC20Metadata": 3342, + "after ": 3343, + "ATION": 3344, + "ative ": 3345, + "MB": 3346, + " ": 3347, + "\"*": 3348, + "cr": 3349, + "contractTokenBalance": 3350, + "ecode\"": 3351, + "\"evm.": 3352, + "\"*\"": 3353, + "\"Address: ": 3354, + "}.\\n *\\n * ": 3355, + "tart": 3356, + "Ar": 3357, + ";\\n ": 3358, + "hal": 3359, + ", but ": 3360, + "protocol": 3361, + "ft": 3362, + "utils/introspection/": 3363, + ") {\\n value ": 3364, + "BuyTax": 3365, + "Do": 3366, + "p ": 3367, + "╬╬": 3368, + ";\\n result += ": 3369, + ";\\n }\\n if (value ": 3370, + "\\n returns (": 3371, + "reasur": 3372, + "ERC721 ": 3373, + "being ": 3374, + "ING": 3375, + "hex": 3376, + "tit": 3377, + "bytes4 interfaceId": 3378, + "(target, data": 3379, + "balance of at least ": 3380, + "ETHSupportingFeeOnTransferTokens": 3381, + "projectId": 3382, + "time": 3383, + "Proof": 3384, + "ticcall": 3385, + "erc": 3386, + "wei": 3387, + "doesn't ": 3388, + "wallet": 3389, + "from `from` to `to": 3390, + "prev": 3391, + "unchecked {": 3392, + ".sol\\\";\\n\\n": 3393, + "previousOwner": 3394, + "restr": 3395, + "address owner = ": 3396, + "collection": 3397, + "SellTax": 3398, + "LT": 3399, + "ed, ": 3400, + "Cre": 3401, + "%%": 3402, + "receive": 3403, + "granted ": 3404, + "(bool success, ": 3405, + "amountOutMin": 3406, + "access ": 3407, + "mint ": 3408, + "IERC721Metadata": 3409, + "both ": 3410, + "ely ": 3411, + ") public view returns (": 3412, + "igin": 3413, + "comp": 3414, + "uint256(": 3415, + "Tokens ": 3416, + "\\n * @": 3417, + "mart ": 3418, + "decreaseAllowance": 3419, + "equivalent to ": 3420, + "s `": 3421, + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev ": 3422, + ")\\n ": 3423, + "yGu": 3424, + "metadata": 3425, + "allowance for ": 3426, + "expect": 3427, + "ilter": 3428, + "ov": 3429, + "whether the ": 3430, + "divid": 3431, + "17": 3432, + "CON": 3433, + "revoke": 3434, + "increaseAllowance": 3435, + "nonce": 3436, + "supportsInterface(bytes4 interfaceId": 3437, + "to` cannot be the zero address.\\n * - `": 3438, + "ustom": 3439, + "existent": 3440, + "isFee": 3441, + "self": 3442, + "never": 3443, + "line ": 3444, + ")\\n external": 3445, + ".\\n *\\n * Requirements:\\n *\\n * - The ": 3446, + "for (uint256 i": 3447, + ";\\r\\n ": 3448, + "insufficient ": 3449, + " token": 3450, + "interfaceId == ": 3451, + "is the ": 3452, + "_Available since v4.": 3453, + "22": 3454, + "cop": 3455, + "automatedMarketMakerPair": 3456, + "ReentrancyGu": 3457, + "pur": 3458, + "ance": 3459, + "bots": 3460, + "because ": 3461, + "throu": 3462, + "As": 3463, + ",\\n bytes memory data": 3464, + "(uint256 a, uint256 b) internal pure returns (": 3465, + "return true": 3466, + "opcode ": 3467, + "OU": 3468, + "int-": 3469, + ", recipient": 3470, + "Active": 3471, + " / ": 3472, + "function is ": 3473, + "learn ": 3474, + "(address(this": 3475, + "more about ": 3476, + "learn more about ": 3477, + "hint-": 3478, + "ption": 3479, + "ve the ": 3480, + "solhint-": 3481, + "WAR": 3482, + "uint128": 3483, + "Set storage ": 3484, + "ner, ": 3485, + "setting": 3486, + "fix": 3487, + "allet ": 3488, + "leaf": 3489, + "[0": 3490, + " or ": 3491, + "[EIP": 3492, + "next ": 3493, + "pric": 3494, + "-= ": 3495, + "{\\n function ": 3496, + ",\\n * but ": 3497, + "refer": 3498, + "Chain": 3499, + "tFee": 3500, + "createPair": 3501, + "Gen": 3502, + "Sale": 3503, + ".sta": 3504, + " of two unsigned integ": 3505, + "Set storage set": 3506, + "_safeMint": 3507, + "inh": 3508, + "decimal": 3509, + "Transfers ": 3510, + "swapTokensAtAmount": 3511, + "super.": 3512, + "-}[`functionCall`],\\n * but ": 3513, + "` and `": 3514, + "14": 3515, + "permit": 3516, + "Factor": 3517, + "standard ": 3518, + "through ": 3519, + ") {\\n // ": 3520, + "15": 3521, + "address) {\\n return ": 3522, + "```": 3523, + "fund": 3524, + "bytes(": 3525, + "fy": 3526, + "sqrt": 3527, + "AN": 3528, + "cess": 3529, + "call failed": 3530, + "Stand": 3531, + "mload(": 3532, + "esired": 3533, + "transfers ": 3534, + "succeeded": 3535, + "TokenOwnership": 3536, + ".\\n */\\n error ": 3537, + "where ": 3538, + "position": 3539, + "rounding ": 3540, + "royalty": 3541, + "1._\\n */\\n function ": 3542, + "- 1": 3543, + "getApproved": 3544, + "Di": 3545, + "PAR": 3546, + "} and {": 3547, + "_F": 3548, + "_marketing": 3549, + "resp": 3550, + "(address to, uint256 ": 3551, + "::::": 3552, + "Rewards": 3553, + ">=": 3554, + "] += ": 3555, + "used to ": 3556, + "errorMessage\\n ": 3557, + "Counter ": 3558, + "assembly {\\n ": 3559, + ",\\n string memory errorMessage\\n ": 3560, + "at the ": 3561, + "YP": 3562, + ")\\\", p0, p1, p2, p3));\\n\\t}\\n\\n\\tfunction log(": 3563, + "Stor": 3564, + "reason": 3565, + "enum": 3566, + "excluded": 3567, + "ffect": 3568, + "''": 3569, + "LO": 3570, + "extraData": 3571, + "oldOwner": 3572, + "fee ": 3573, + "delegate": 3574, + ". O(1": 3575, + "slot ": 3576, + "to a ": 3577, + "reasury": 3578, + "allowed to ": 3579, + "renounceOwnership": 3580, + "address of the ": 3581, + "SafeCast": 3582, + "RoleAdmin": 3583, + "roy": 3584, + "ically ": 3585, + "is an ": 3586, + "ates ": 3587, + "statu": 3588, + "********************************": 3589, + "(token": 3590, + "boolean value ": 3591, + "By": 3592, + "encod": 3593, + "counter": 3594, + "gram": 3595, + "supportsInterface": 3596, + "indicating whether the ": 3597, + "ree": 3598, + "TokenId ": 3599, + "mapping ": 3600, + " to the ": 3601, + "} event.\\n */\\n function _": 3602, + "();\\n\\n ": 3603, + "scal": 3604, + "tokenId` must exist": 3605, + ".staticcall": 3606, + "when `from": 3607, + ");\\n }": 3608, + "SeaDrop": 3609, + "operation succeeded": 3610, + ".\\n *\\n * Requirements:\\n *\\n * - `from": 3611, + "ound ": 3612, + "boolean value indicating whether the ": 3613, + "boolean value indicating whether the operation succeeded": 3614, + "\\n _": 3615, + "bytes memory returndata": 3616, + "(address owner, address spender": 3617, + "48": 3618, + "BP": 3619, + "s\\n ": 3620, + "block.number": 3621, + ") external;\\n\\n /**\\n * @dev ": 3622, + "_000": 3623, + ".\\n": 3624, + "det": 3625, + "s.length": 3626, + ";\\n\\t": 3627, + "representation": 3628, + ">= amount": 3629, + "static ": 3630, + "28": 3631, + "ties": 3632, + "filte": 3633, + "gi": 3634, + "rant": 3635, + "Sub": 3636, + "burn ": 3637, + "Returns a boolean value indicating whether the operation succeeded": 3638, + "permis": 3639, + "send ": 3640, + "uint256 private constant _": 3641, + "defined ": 3642, + "/\\n ": 3643, + ",,,,": 3644, + "edition": 3645, + "author": 3646, + "ong ": 3647, + "prevOwnership": 3648, + "Acc": 3649, + "Multi": 3650, + "enti": 3651, + "Al": 3652, + "eration": 3653, + "make ": 3654, + "collateral": 3655, + "high": 3656, + "a / ": 3657, + "\"Ownable: ": 3658, + "`tokenId` token ": 3659, + "uction": 3660, + "map": 3661, + "\\r\\n * ": 3662, + "overn": 3663, + "pow": 3664, + "} that ": 3665, + "execution ": 3666, + "IMPORTANT: ": 3667, + ") {\\n _": 3668, + "vailable": 3669, + "\\n view": 3670, + "amountB": 3671, + "` must be ": 3672, + "ecim": 3673, + "recipient, uint256 amount": 3674, + "\\n // ": 3675, + "tive ": 3676, + "ication ": 3677, + "comput": 3678, + "ative": 3679, + "981": 3680, + "(x": 3681, + "{approve} or {": 3682, + "the caller must have ": 3683, + "drop": 3684, + "ea": 3685, + "math": 3686, + "_rOwned": 3687, + "` is zero, `amount` ": 3688, + "on\\n * overflow": 3689, + "GN": 3690, + "sha": 3691, + "ant ": 3692, + "set. O(1": 3693, + "doc\"": 3694, + "acklist": 3695, + "65": 3696, + "(account, ": 3697, + ", includ": 3698, + "uint256 internal ": 3699, + "contract is ": 3700, + "contracts ": 3701, + "zero.\\n *\\n * ": 3702, + "approvedAddress": 3703, + "_maxWallet": 3704, + "rAmount": 3705, + "ers ": 3706, + "control": 3707, + "_ROLE": 3708, + "\\n // =============================================================": 3709, + "title ": 3710, + "msgData": 3711, + "Thres": 3712, + "mainSe": 3713, + "Static": 3714, + "bbl": 3715, + "` must have ": 3716, + "ToSwap": 3717, + " of two unsigned integers, ": 3718, + "with `": 3719, + "\\n */\\nabstract contract ": 3720, + "final": 3721, + "caller is not the owner": 3722, + ").max": 3723, + "Can ": 3724, + "Calling ": 3725, + "`target` ": 3726, + " of the token": 3727, + "stored ": 3728, + "`owner` ": 3729, + "=============================================================\\n // ": 3730, + ", errorMessage": 3731, + "//////": 3732, + "_operator": 3733, + "10**": 3734, + "(`": 3735, + "Revok": 3736, + "bubbl": 3737, + "_msgData": 3738, + ") == ": 3739, + "StaticCall": 3740, + "(\\n address target": 3741, + "prec": 3742, + "abil": 3743, + "owned": 3744, + ".sol\\\";\\nimport \\\"../../": 3745, + "If the ": 3746, + "s a `": 3747, + "inher": 3748, + "custom": 3749, + "functionStaticCall": 3750, + "Context ": 3751, + "{transferFrom": 3752, + "OK": 3753, + "include": 3754, + "imits": 3755, + "amount1": 3756, + "bel": 3757, + " that is ": 3758, + "elop": 3759, + "optim": 3760, + "Contract ": 3761, + "struction": 3762, + "amount0": 3763, + "Paused": 3764, + ");\\r\\n\\r\\n ": 3765, + "(\\n uint256 ": 3766, + "digits": 3767, + ".\\r\\n *\\r\\n * ": 3768, + "ister": 3769, + "rows ": 3770, + "created": 3771, + "detail": 3772, + "disable-": 3773, + "spender` cannot be the zero address": 3774, + "router": 3775, + "mainSeparator": 3776, + "() external view returns (string memory": 3777, + "swapExactTokensForETHSupportingFeeOnTransferTokens": 3778, + "\\\"\\n ": 3779, + "bytes32 role": 3780, + "Role(bytes32 role": 3781, + "swapTokensForEth": 3782, + "Metadata ": 3783, + "RR": 3784, + "sue": 3785, + ",\\n uint amount": 3786, + "Votes": 3787, + "owned by `from": 3788, + "swapping": 3789, + "() internal view virtual returns (": 3790, + "`) ": 3791, + "curr": 3792, + "reentr": 3793, + "\\n * - ": 3794, + "LP": 3795, + ") {\\n return ": 3796, + "ASCI": 3797, + "has been ": 3798, + ".\\n *\\n * _Available since v3.1._\\n */\\n function ": 3799, + "` operator.\\n *\\n * Requirements:\\n *\\n * - ": 3800, + "ASCII": 3801, + "i.": 3802, + "(address target, ": 3803, + "0.5": 3804, + "oft": 3805, + "mapping(address => uint256": 3806, + "-onERC721Received": 3807, + "another ": 3808, + "mechanisms": 3809, + "IERC721Receiver-onERC721Received": 3810, + "of ``from``'s ": 3811, + "ze ": 3812, + "4._": 3813, + "InvalidSignature": 3814, + "\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0": 3815, + "form": 3816, + "safe ": 3817, + "sion ": 3818, + "Befo": 3819, + "lob": 3820, + "Cannot ": 3821, + "ReentrancyGuard": 3822, + "uni": 3823, + "a contract ": 3824, + "Convert": 3825, + "work": 3826, + "the updated ": 3827, + "spender, amount": 3828, + "be\\n * ": 3829, + "(address(0), to, ": 3830, + "_TYP": 3831, + "upgrade": 3832, + ",\\r\\n uint256 ": 3833, + "//////////////": 3834, + ", address account": 3835, + "` to `": 3836, + "delete ": 3837, + "OL": 3838, + "check ": 3839, + "ray ": 3840, + "division by ": 3841, + "functionDelegate": 3842, + "fit in ": 3843, + "(address target, bytes memory data": 3844, + "functionDelegateCall": 3845, + "(sender": 3846, + "(to, ": 3847, + ". The ": 3848, + "quantity ": 3849, + "Param": 3850, + "sour": 3851, + ", 1": 3852, + "share": 3853, + "see ": 3854, + "to, uint256 amount": 3855, + "a balance of at least ": 3856, + "Exceed": 3857, + "\\n * @dev ": 3858, + "MAIN": 3859, + "-assembly": 3860, + ".selector": 3861, + "_exists": 3862, + "config": 3863, + "pause": 3864, + "flag": 3865, + "conditions:": 3866, + "Div": 3867, + "Manag": 3868, + " that is called ": 3869, + "ZeroAddress": 3870, + "Weight": 3871, + "a balance of at least `amount": 3872, + "Vault": 3873, + "_holder": 3874, + "solhint-disable-": 3875, + "_P": 3876, + "equ": 3877, + "ust": 3878, + "\"// SPDX-License-Identifier: MIT\\n": 3879, + "OKEN": 3880, + "elopment": 3881, + "\"\"": 3882, + "is\\n * ": 3883, + "Upgradeable": 3884, + "the updated allowance": 3885, + "Fl": 3886, + "over ": 3887, + "mod ": 3888, + "/*": 3889, + "max ": 3890, + "result is ": 3891, + "buyTotalFees": 3892, + "& ": 3893, + "indicating the updated allowance": 3894, + "} event indicating the updated allowance": 3895, + "addLiquidityETH": 3896, + "using-": 3897, + "();\\n\\n ": 3898, + ") external;\\n\\n ": 3899, + "total supply": 3900, + "Percentage": 3901, + "OMAIN": 3902, + "Sh": 3903, + "to\\n * ": 3904, + "actual": 3905, + "Lib": 3906, + "andom": 3907, + "\\n */\\ninterface ": 3908, + "_tokenApproval": 3909, + "Back": 3910, + "Ver": 3911, + ");\\n }\\n\\n /**\\n * @dev See {": 3912, + "(\\n address target,\\n bytes memory data": 3913, + ": value ": 3914, + "values ": 3915, + "performing a ": 3916, + "Storage": 3917, + "5d": 3918, + "value of ": 3919, + "v2": 3920, + "bas": 3921, + "\\n * {": 3922, + "allows ": 3923, + ",\\n \\\"": 3924, + "largest ": 3925, + "per ": 3926, + "Mapping ": 3927, + "` and `to` are both ": 3928, + "(\\n address from,\\n address to,\\n uint256 tokenId\\n ": 3929, + "` and `to` are both non-": 3930, + "ethFor": 3931, + "unt": 3932, + "ary ": 3933, + "The": 3934, + "Balance = ": 3935, + "*/": 3936, + "_B": 3937, + ", \\\"Address: low-level ": 3938, + "off": 3939, + "1000": 3940, + "Move": 3941, + "Calling conditions:": 3942, + "/= ": 3943, + "amount);\\n\\n ": 3944, + "checkpoint": 3945, + "produc": 3946, + "2^256": 3947, + "half ": 3948, + "exce": 3949, + "amountA": 3950, + "eta": 3951, + "program": 3952, + ") internal virtual {": 3953, + "UN": 3954, + "distribu": 3955, + "able to ": 3956, + "ERC2981": 3957, + "ually ": 3958, + "An": 3959, + "this contract ": 3960, + "automa": 3961, + "(\\r\\n ": 3962, + " (when the ": 3963, + "reverting on\\n * overflow": 3964, + "fallback": 3965, + "address(this).": 3966, + "stop": 3967, + "ary": 3968, + "} from ": 3969, + "Pausable": 3970, + "access/Ownable": 3971, + "head": 3972, + "rele": 3973, + "minted": 3974, + " == 0": 3975, + "previous ": 3976, + "Threshold": 3977, + "OPER": 3978, + "e: ": 3979, + "\\n */\\n ": 3980, + "!= address(0), \\\"": 3981, + "Only ": 3982, + "new owner": 3983, + "MP": 3984, + "Map": 3985, + "next-": 3986, + "mint to ": 3987, + "IUniswapV2Factory": 3988, + "calcul": 3989, + "shares": 3990, + "TRA": 3991, + "// =============================================================\\n // ": 3992, + "locked": 3993, + "tradingOpen": 3994, + "Hold": 3995, + "Number": 3996, + "78": 3997, + "cle": 3998, + "able is ": 3999, + "See ": 4000, + "uint160": 4001, + "interfaceId == type(": 4002, + "\\ti": 4003, + "creases the ": 4004, + "Hook that is called ": 4005, + "ample": 4006, + "(address indexed owner": 4007, + "(msg.sender, ": 4008, + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `": 4009, + "oin": 4010, + "rer": 4011, + "bytes calldata ": 4012, + "\\r\\n */\\r\\n function ": 4013, + "_ENT": 4014, + "minting ": 4015, + "the zero address\\\");\\n\\n _beforeTokenTransfer": 4016, + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `": 4017, + "state": 4018, + "delegatee": 4019, + "_initial": 4020, + "_SE": 4021, + "MINT": 4022, + "////////////////////////////////////////////////": 4023, + "Day": 4024, + "IS": 4025, + "to\\n * ": 4026, + "Initialized": 4027, + "descri": 4028, + "uint256,": 4029, + "ame": 4030, + "aux": 4031, + "Using ": 4032, + "minted for ": 4033, + "} from \\\"": 4034, + ", 0": 4035, + "tx": 4036, + "INIT": 4037, + "takeFee": 4038, + "(data": 4039, + "and the ": 4040, + ". ": 4041, + "SO": 4042, + "sale": 4043, + "the\\n * ": 4044, + "tokenId` token ": 4045, + "tick": 4046, + "issue": 4047, + "secur": 4048, + "it is ": 4049, + " both ": 4050, + "sellTotalFees": 4051, + "` and `to` are both non-zero, ": 4052, + "Standard": 4053, + "next-line ": 4054, + "Cur": 4055, + "data. ": 4056, + "role ": 4057, + "same ": 4058, + "\\\");": 4059, + "approve(address spender": 4060, + ") >> ": 4061, + "liquidityFee": 4062, + "(address indexed owner, address indexed ": 4063, + "base ": 4064, + "prod0": 4065, + "309": 4066, + "change ": 4067, + "Fin": 4068, + "account, amount": 4069, + "transfer(address ": 4070, + "Role(bytes32 role, address account": 4071, + "\\n *\\n * - ": 4072, + "construction": 4073, + "subscription": 4074, + "royalty ": 4075, + ", ) = ": 4076, + "tokens are ": 4077, + "call to non-": 4078, + "Liquify": 4079, + "allTokens": 4080, + ". This include": 4081, + "while (": 4082, + "request": 4083, + "SafeCast: value ": 4084, + "eas": 4085, + "kn": 4086, + "uint112": 4087, + "call.\\n *\\n * _Available since v3.": 4088, + "as an ": 4089, + "-}[`functionCall`],\\n * but performing a ": 4090, + "toString": 4091, + "ed to the ": 4092, + "--------------------------------": 4093, + "_buyCount": 4094, + "role, ": 4095, + ") internal returns (bytes memory) {\\n return ": 4096, + "ERED": 4097, + "consum": 4098, + "se if (": 4099, + "DevFee": 4100, + "io/": 4101, + "call to non-contract": 4102, + "_new": 4103, + "available": 4104, + "mul(": 4105, + "keccak256(": 4106, + "src/": 4107, + "` and `to` are never": 4108, + "Fee ": 4109, + "` and `to` are never both ": 4110, + "lang": 4111, + "import {": 4112, + "QueryFor": 4113, + "Calling conditions:\\n *\\n * - ": 4114, + "46": 4115, + "TION": 4116, + "(address account, uint256 amount": 4117, + "IAL": 4118, + "AddressData": 4119, + "start ": 4120, + "`, it ": 4121, + "(address(0), account, amount": 4122, + "automatedMarketMakerPairs": 4123, + "Gener": 4124, + "umul": 4125, + ") external returns (": 4126, + "token/ERC20/extensions/": 4127, + ", uint256 value": 4128, + "\\n *\\n * This ": 4129, + "ed by the ": 4130, + "OOOO": 4131, + "decode": 4132, + "way": 4133, + "(uint256 value) internal pure returns (": 4134, + "ChainId": 4135, + "so ": 4136, + "ERC721Receiver": 4137, + "` is the ": 4138, + "99": 4139, + "one": 4140, + "from` and `to` are never both ": 4141, + "Type": 4142, + "solhint-disable-next-line ": 4143, + "INITIAL": 4144, + ");\\n uint256 ": 4145, + "sec": 4146, + "approv": 4147, + "(account, address(0), ": 4148, + "y-": 4149, + "value: ": 4150, + "(address from": 4151, + "} else {\\n ": 4152, + "downcasted ": 4153, + "use {": 4154, + "approve}": 4155, + "initi": 4156, + "_ownership": 4157, + "div(": 4158, + ", r": 4159, + "value is ": 4160, + "EIP712": 4161, + "hash ": 4162, + " - 1": 4163, + " = 0; i": 4164, + "ery ": 4165, + "marketingWallet": 4166, + "tryRecover": 4167, + "OrOwner": 4168, + " not ": 4169, + "_uniswapV2Router": 4170, + "doesn't fit in ": 4171, + "SafeCast: value doesn't fit in ": 4172, + "address public ": 4173, + "(uint256 => ": 4174, + "amount exceeds allowance": 4175, + "Account": 4176, + "Desired": 4177, + "FeeOnSell": 4178, + "rewards": 4179, + "AB": 4180, + "Cop": 4181, + "altern": 4182, + "calling ": 4183, + ");\\n }\\n }\\n\\n /**\\n * @dev ": 4184, + ") public virtual override returns (bool) {\\n ": 4185, + "run": 4186, + "tokenIds": 4187, + "contractBalance": 4188, + "Pri": 4189, + "glob": 4190, + "\\n uint256 ": 4191, + "FeeReceiver": 4192, + "string` ": 4193, + "maxTransaction": 4194, + "() external view returns (uint256": 4195, + "Ext": 4196, + "rati": 4197, + ".sol\\\";\\nimport \\\"@openzeppelin/contracts/": 4198, + "langu": 4199, + "3._\\n */\\n function ": 4200, + "rede": 4201, + "- amount": 4202, + " `string` ": 4203, + "End": 4204, + "s with ": 4205, + "register": 4206, + "_transferOwnership(": 4207, + "increment": 4208, + "subtraction": 4209, + "> 0": 4210, + "avo": 4211, + "isExcluded": 4212, + "_taxWallet": 4213, + "ide": 4214, + "so": 4215, + "If the call": 4216, + "amountETHMin": 4217, + "amountTokenMin": 4218, + "transferred to `to`.\\n * - ": 4219, + "removeLiquidity": 4220, + "alternative ": 4221, + "es: ": 4222, + "array ": 4223, + "support ": 4224, + "ing to ": 4225, + ");\\n event ": 4226, + "set._in": 4227, + "Share": 4228, + "ASCII `string` ": 4229, + "vides ": 4230, + "below ": 4231, + "see {": 4232, + "nonces": 4233, + ".\\n *\\n * Emits an {Approval} event indicating the updated allowance": 4234, + "uint256 internal constant ": 4235, + "specifi": 4236, + "addresses": 4237, + "re the ": 4238, + "rapp": 4239, + "respond": 4240, + "Before": 4241, + "minted for `to`.\\n * - ": 4242, + " The ": 4243, + " ** ": 4244, + "LE_ADDRESS": 4245, + "_final": 4246, + "\\n * @param _": 4247, + "eld": 4248, + ");\\n ": 4249, + "0;\\n ": 4250, + "e18": 4251, + "cove": 4252, + "Com": 4253, + "; i++": 4254, + "Remo": 4255, + "uses ": 4256, + "CONSO": 4257, + "4._\\n */\\n function ": 4258, + "CONSOLE_ADDRESS": 4259, + "\\n * ": 4260, + "Throws ": 4261, + "== 0) {\\n ": 4262, + "target ": 4263, + "Recipient": 4264, + "openzeppelin-": 4265, + "ignored": 4266, + "[] memory": 4267, + "manage ": 4268, + ";\\n\\t}\\n\\n\\tfunction ": 4269, + "200": 4270, + "ing.": 4271, + "override returns (bool": 4272, + "transfer to the zero address\"": 4273, + "mart contract": 4274, + "_TYPE": 4275, + "afely ": 4276, + "ized": 4277, + " && ": 4278, + "URN": 4279, + "Changed": 4280, + ", it must ": 4281, + "84": 4282, + "_packedOwnership": 4283, + "gh": 4284, + "issu": 4285, + "query ": 4286, + "Withdraw": 4287, + "permission": 4288, + "Returns true if the ": 4289, + "PARATOR": 4290, + "ERC165 ": 4291, + "Point": 4292, + "decreased ": 4293, + "minter": 4294, + "Registry": 4295, + "old ": 4296, + "currentRate": 4297, + "correct": 4298, + "{\\n // ": 4299, + "leaves": 4300, + " overflow\"": 4301, + "new owner is ": 4302, + "address[] calldata ": 4303, + "conc": 4304, + "\\n\\n ": 4305, + "));\\n\\t\\ti": 4306, + ".\\n */\\ninterface ": 4307, + ",uint256 ": 4308, + "13": 4309, + "Start": 4310, + "gnored": 4311, + "size ": 4312, + ") internal view {\\n\\t\\t(bool ": 4313, + ".staticcall(abi.encodeWithSignature(\\\"log(": 4314, + "\\n // =============================================================\\n\\n /**\\n * @dev ": 4315, + "OMAIN_SE": 4316, + ", ) = CONSOLE_ADDRESS": 4317, + "ignored, ) = CONSOLE_ADDRESS": 4318, + "));\\n\\t\\tignored": 4319, + ") internal view {\\n\\t\\t(bool ignored, ) = CONSOLE_ADDRESS": 4320, + "OMAIN_SEPARATOR": 4321, + ") internal view {\\n\\t\\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature(\\\"log(": 4322, + "UP": 4323, + "balanceOf(address account": 4324, + "only be called by ": 4325, + "() external view returns (string memory);\\n\\n /**\\n * @dev Returns the ": 4326, + "uce": 4327, + ".\\n * @param ": 4328, + "orac": 4329, + "mapping(uint256 => ": 4330, + "ched": 4331, + "interfaces": 4332, + "();\\n\\n /**\\n * ": 4333, + "));\\n\\t\\tignored;\\n\\t}\\n\\n\\tfunction ": 4334, + "(address _": 4335, + "packedAddressData": 4336, + "Grant": 4337, + "[owner][spender": 4338, + "New": 4339, + "_IN": 4340, + "AutomatedMarketMakerPair": 4341, + "\\n * @title ": 4342, + "wis": 4343, + "tup": 4344, + "⣿⣿": 4345, + ".\\n *\\n * Calling conditions:\\n *\\n * - ": 4346, + "\\t\\t": 4347, + "term": 4348, + "allowance below ": 4349, + ".\\r\\n */\\r\\n function ": 4350, + "excludeFromMaxTransaction": 4351, + "decreased allowance below ": 4352, + "ert": 4353, + "ingle ": 4354, + "Rati": 4355, + "uint deadline": 4356, + "returndata_": 4357, + "Pre": 4358, + "ord": 4359, + ") external view returns (bool": 4360, + "iod": 4361, + "\"@openzeppelin/contracts/utils/": 4362, + "the zero address\\\");\\n require(": 4363, + ".\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist": 4364, + "prevent ": 4365, + "224": 4366, + "case ": 4367, + "pragma solidity >=": 4368, + "ATA": 4369, + ";\\n\\n // Mapping ": 4370, + "Def": 4371, + "(address spender, uint256 ": 4372, + "Returns true if ": 4373, + "\\n//": 4374, + "from, address indexed ": 4375, + "calls to ": 4376, + "It will ": 4377, + "dif": 4378, + "\\n\\n function ": 4379, + "allowance(address owner, address spender": 4380, + "\\r\\n *\\r\\n * ": 4381, + "returned ": 4382, + "ethBalance": 4383, + "way to ": 4384, + "())": 4385, + "s]": 4386, + " > 0) {\\n value ": 4387, + ";\\n }\\n if (value >> ": 4388, + "approve(address spender, uint256 amount": 4389, + " > 0) {\\n value >>= ": 4390, + "oo": 4391, + "10 ** ": 4392, + "uint8 v": 4393, + "math/": 4394, + "Can only be called by ": 4395, + "uint24": 4396, + "set to ": 4397, + "ish": 4398, + ".\\n *\\n * IMPORTANT: ": 4399, + "Proxy": 4400, + "manag": 4401, + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../": 4402, + ",\\r\\n ": 4403, + "IZ": 4404, + "Mask": 4405, + "Exempt": 4406, + "returndata, errorMessage": 4407, + "small": 4408, + "allowance of `": 4409, + "inverse": 4410, + "specific ": 4411, + "arant": 4412, + "() public view virtual override returns (string memory) {\\n return ": 4413, + "ict ": 4414, + "\\\");\\r\\n ": 4415, + "ownedTokens": 4416, + "i.e. ": 4417, + " <= ": 4418, + "Public ": 4419, + "_dev": 4420, + "\\r\\n * ": 4421, + "maximum ": 4422, + "//////////////////////////////////////////////////////////////": 4423, + "Merkle": 4424, + ", as ": 4425, + "s of the ": 4426, + ".sol'": 4427, + "\\\\x8": 4428, + "maxTransactionAmount": 4429, + "Data ": 4430, + "NING": 4431, + "ing all ": 4432, + "overflow ": 4433, + "whenNot": 4434, + "WARNING": 4435, + "[to": 4436, + "actual ": 4437, + "Is": 4438, + "0x7": 4439, + "_allowances[owner][spender": 4440, + "rounded ": 4441, + "inherit": 4442, + "process": 4443, + ";\\n\\n // ": 4444, + "implementation ": 4445, + "rFee": 4446, + "adoc": 4447, + ": invalid ": 4448, + "if it ": 4449, + ").\\n * ": 4450, + "xref:": 4451, + ".\\n */\\nabstract contract ": 4452, + "];\\n require(": 4453, + " may ": 4454, + ")\\n": 4455, + "23": 4456, + ");\\n\\n /**\\n * @dev Emitted when ": 4457, + "immutable": 4458, + "equal": 4459, + "_TYPEHASH": 4460, + "sal": 4461, + "................": 4462, + "standard": 4463, + "a smart contract": 4464, + "librari": 4465, + "supportsInterface(bytes4 interfaceId) public view virtual ": 4466, + "ffffffffffffffff": 4467, + "When `from": 4468, + "iste": 4469, + "keccak256(abi.encode": 4470, + "Bot": 4471, + "how ": 4472, + "y/": 4473, + "SD": 4474, + "output": 4475, + "over the ": 4476, + "Auth": 4477, + "Bytes32": 4478, + "as the allowance of `": 4479, + "(address to, uint256 tokenId": 4480, + "sa": 4481, + "}\\n * ": 4482, + "move ": 4483, + ". This is ": 4484, + "deployed": 4485, + "the current owner": 4486, + "ever ": 4487, + "Default": 4488, + "as the allowance of `spender` ": 4489, + "` to the ": 4490, + " + 1": 4491, + "Solidity function ": 4492, + "ally, ": 4493, + "(bool success, bytes memory returndata": 4494, + "owned by `from`.\\n * - ": 4495, + "burning": 4496, + "ERC2309": 4497, + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token ": 4498, + "describ": 4499, + "language": 4500, + "etc": 4501, + "`target` revert": 4502, + "emits ": 4503, + "correspond": 4504, + "\"ERC20: transfer from the zero address\"": 4505, + "liqui": 4506, + "ownership.": 4507, + "Mem": 4508, + "cy": 4509, + "day": 4510, + "arith": 4511, + "amount;\\n ": 4512, + "\"ERC20: transfer to the zero address\"": 4513, + "ere": 4514, + "kee": 4515, + "s` ": 4516, + "\\n * ": 4517, + ");\\n }\\n\\n ": 4518, + "them ": 4519, + "norm": 4520, + "refers to ": 4521, + "Interface ": 4522, + "(to": 4523, + "F5": 4524, + "LI": 4525, + "how": 4526, + "Delay": 4527, + "Pauser": 4528, + "licen": 4529, + "} to ": 4530, + "import '": 4531, + "RY": 4532, + "(address newOwner": 4533, + "a single ": 4534, + "Internal ": 4535, + "startTimestamp": 4536, + "ould": 4537, + "vidend": 4538, + "ITY": 4539, + "default ": 4540, + "need to ": 4541, + "_approve(owner, ": 4542, + "tTeam": 4543, + "ensu": 4544, + "orrow": 4545, + "ingFactor": 4546, + "\\\");\\n unchecked {\\n ": 4547, + ";\\n uint256 internal constant ": 4548, + "` to its ": 4549, + "Config": 4550, + "DEF": 4551, + "Converts a `": 4552, + "dividing ": 4553, + ".\\n */\\n function name": 4554, + ".\\n */\\n function symbol": 4555, + "] = _": 4556, + ".\\n */\\n constructor(": 4557, + "information ": 4558, + ", b": 4559, + "\\n uint256 ": 4560, + "cost": 4561, + "-contracts.": 4562, + "Dest": 4563, + "medi": 4564, + "add ": 4565, + "_totalSupply ": 4566, + "Dividend": 4567, + "-contracts.adoc": 4568, + "Orac": 4569, + "aun": 4570, + "ptr": 4571, + "main ": 4572, + " {\\n /**\\n * @dev Returns the ": 4573, + ", IERC20": 4574, + "an owner": 4575, + ";\\n\\n // The ": 4576, + "bound": 4577, + "impos": 4578, + "own ": 4579, + ";\\n\\nimport \\\"./": 4580, + "]\\n * ": 4581, + ",\\n bytes memory ": 4582, + "\\n\\t *": 4583, + "` to its ASCII `string` ": 4584, + "% ": 4585, + "for a ": 4586, + "Packed(": 4587, + "vot": 4588, + "Transfer(address indexed ": 4589, + "\\n */\\nlibrary ": 4590, + "ROOT": 4591, + "at least": 4592, + "Can only be called by the current owner": 4593, + "_projectId": 4594, + "fic": 4595, + "usually ": 4596, + "accountBalance": 4597, + ") {\\r\\n return ": 4598, + "vert ": 4599, + "internal function is ": 4600, + "contract without ": 4601, + "nextTokenId": 4602, + "internal function is equivalent to ": 4603, + "{ERC20": 4604, + ");\\n if (": 4605, + "allowance(": 4606, + "log(address ": 4607, + "sendValue": 4608, + "tokensForLiquidity": 4609, + "{IERC20-approve}": 4610, + "swap ": 4611, + ").\\n *\\n * Counterpart to Solidity's `": 4612, + "Sy": 4613, + "fals": 4614, + "ables ": 4615, + "should be ": 4616, + "write": 4617, + "_DATA": 4618, + "fixed ": 4619, + "60": 4620, + "U ": 4621, + "- the ": 4622, + ");\\n }\\n\\n /**\\n * @dev Transfers ": 4623, + ",\\n uint256 value": 4624, + "`account`, ": 4625, + ",\\r\\n address ": 4626, + "Pres": 4627, + "Mod": 4628, + "amount exceeds balance\"": 4629, + "Destroy": 4630, + "ml": 4631, + "solidity ": 4632, + "BITPOS_N": 4633, + "If `to` ": 4634, + "General ": 4635, + "a smart contract, it must ": 4636, + "refers to a smart contract, it must ": 4637, + "If `to` refers to a smart contract, it must ": 4638, + "view override returns (": 4639, + "Signed": 4640, + "sellLiquidityFee": 4641, + ".\\n * - ": 4642, + "_add": 4643, + "ident": 4644, + ", address p1": 4645, + "bool p1": 4646, + "string memory p1": 4647, + "p0, address p1": 4648, + "p0, bool p1": 4649, + "p0, string memory p1": 4650, + "GNU ": 4651, + "// The ": 4652, + "DEFAU": 4653, + "recove": 4654, + "around ": 4655, + "BaseURI": 4656, + "information": 4657, + "call{": 4658, + "OnERC721Received": 4659, + "\\\\xe": 4660, + "MaxTransactionAmount": 4661, + "Creator": 4662, + "Snapshot": 4663, + "uint256 result = ": 4664, + "_reduce": 4665, + "ZZZZZZZZ": 4666, + "Transfer(address indexed from, address indexed ": 4667, + "the `": 4668, + "a `": 4669, + "(address registrant": 4670, + ");\\n error ": 4671, + "If the caller is not ": 4672, + "xref:ROOT": 4673, + "xref:ROOT:": 4674, + "By ": 4675, + "`).\\n *\\n * ": 4676, + "See the ": 4677, + "[]": 4678, + "_EX": 4679, + ") + ": 4680, + "prod1": 4681, + "Moves `amount` tokens from ": 4682, + "openzeppelin-contracts/": 4683, + "General Public ": 4684, + "ems ": 4685, + "and burning": 4686, + "ETHBalance": 4687, + "of `owner": 4688, + "(bool success, bytes memory returndata) = ": 4689, + "described in ": 4690, + "-safe": 4691, + "c = ": 4692, + "uint256` to its ASCII `string` ": 4693, + "origin": 4694, + "fees ": 4695, + "____": 4696, + "nextInitialized": 4697, + "role, account": 4698, + "Converts a `uint256` to its ASCII `string` ": 4699, + " to `to": 4700, + "ownerOf(tokenId": 4701, + "OperatorFilte": 4702, + "security": 4703, + "initial ": 4704, + "[from": 4705, + ".\\n */\\n modifier ": 4706, + "EIP-": 4707, + ">= amount, \\\"ERC20: ": 4708, + "pt ": 4709, + "_msgSenderERC721A": 4710, + ", so ": 4711, + " != address(0), \\\"ERC20: approve ": 4712, + "head to ": 4713, + "setup": 4714, + "that can be ": 4715, + "reverting on\\n * overflow (when the ": 4716, + "0d": 4717, + "vide ": 4718, + "returns(": 4719, + "memory-safe": 4720, + "the caller's ": 4721, + "solidity memory-safe": 4722, + "(bool success, bytes memory returndata) = target": 4723, + "solidity memory-safe-assembly": 4724, + "ally-": 4725, + "divis": 4726, + "FeeOnBuy": 4727, + "} else if (": 4728, + "html": 4729, + "To learn more about ": 4730, + "metadata\"": 4731, + "GNU General Public ": 4732, + "uri": 4733, + "low ": 4734, + "which is called ": 4735, + "}, which is called ": 4736, + "IERC721Receiver-onERC721Received}, which is called ": 4737, + "\"metadata\"": 4738, + "rel": 4739, + "assum": 4740, + "Transfer ": 4741, + ". Th": 4742, + "\\r\\n\\r\\n": 4743, + "\\r\\n ": 4744, + "State": 4745, + "hooks, ": 4746, + "possible to ": 4747, + ".\\n * ": 4748, + "any": 4749, + "`from`, it ": 4750, + "Protocol": 4751, + "enabled\"": 4752, + "purpos": 4753, + "custom ": 4754, + "If the caller is not `from`, it ": 4755, + "(), ": 4756, + "\\n if (": 4757, + "unable to ": 4758, + "bool _": 4759, + "abo": 4760, + "this method ": 4761, + "paramet": 4762, + "Whitelist": 4763, + "Initializes the ": 4764, + "IL": 4765, + " is not ": 4766, + "Sets the ": 4767, + "/// @solidity memory-safe-assembly": 4768, + "Ratio": 4769, + "\\\");\\n _": 4770, + "call failed\\\"": 4771, + "using-hook": 4772, + "Using Hook": 4773, + "head to xref:ROOT:": 4774, + "To learn more about hooks, ": 4775, + "To learn more about hooks, head to xref:ROOT:": 4776, + "abi.decode": 4777, + "effect": 4778, + "ure": 4779, + "ene": 4780, + "ETHTo": 4781, + "}\\n\\n // ": 4782, + ") public view virtual returns (": 4783, + "\\u003e ": 4784, + "by either ": 4785, + "token is ": 4786, + "s.io/": 4787, + "ixed": 4788, + "upon ": 4789, + "making ": 4790, + "{approve} or {setApprovalForAll": 4791, + "recovered": 4792, + "by either {approve} or {setApprovalForAll": 4793, + "(address from, address ": 4794, + "rang": 4795, + "extending": 4796, + "overrid": 4797, + ");\\n }\\n ": 4798, + "transaction ": 4799, + "\\n * function ": 4800, + "ble ": 4801, + "with {": 4802, + ").interfaceId ": 4803, + "\\n\\t * ": 4804, + ", string memory errorMessage": 4805, + "for (uint256 i = 0; i": 4806, + ", recipient, amount": 4807, + "#using-hook": 4808, + ", v": 4809, + "(address operator": 4810, + "proxy": 4811, + ", address p2": 4812, + "s[Using Hook": 4813, + ", string memory p2": 4814, + "(uint256 tokenId) external view returns (": 4815, + ", bool p2": 4816, + "mechanism ": 4817, + "-contracts.adoc#using-hook": 4818, + "To learn more about hooks, head to xref:ROOT:extending": 4819, + "-contracts.adoc#using-hooks[Using Hook": 4820, + "To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hook": 4821, + "_allTokens": 4822, + "etwe": 4823, + ");\\n }\\n\\n /**\\n * @notice ": 4824, + "erc20": 4825, + ".\\n ": 4826, + "VER": 4827, + "caller ": 4828, + "should": 4829, + "payment": 4830, + "(\\n address from,\\n address to,\\n uint256 amount\\n ": 4831, + "cap": 4832, + "name of the ": 4833, + "on be": 4834, + ";\\n uint256 public ": 4835, + "].\\n *\\n * ": 4836, + "You ": 4837, + "}\\n ": 4838, + "\\\", \\\"": 4839, + "Invariant": 4840, + "Stake": 4841, + "guarant": 4842, + "34": 4843, + "ence": 4844, + ", we ": 4845, + "address to ": 4846, + "Caller": 4847, + "log2": 4848, + "play": 4849, + "address owner = _msgSender(": 4850, + "enumer": 4851, + "(data);\\n return ": 4852, + "ell": 4853, + "again": 4854, + "require(b": 4855, + "comm": 4856, + "Sets `amount` ": 4857, + "adminRole": 4858, + "_rTotal": 4859, + "0.6.0": 4860, + "`tokenId` token from `from` to `to": 4861, + "_maxWalletSize": 4862, + "_startTokenId": 4863, + "setting ": 4864, + "denominator * ": 4865, + "success, returndata, errorMessage": 4866, + "Sets `amount` as the allowance of `spender` ": 4867, + "Name": 4868, + ") external view returns (uint256);\\n\\n /**\\n * @dev ": 4869, + "),": 4870, + "3c": 4871, + "Govern": 4872, + "Pric": 4873, + ");\\n }\\n\\n /**\\n * @dev See {IERC721-": 4874, + "< _": 4875, + "public constant ": 4876, + "`index": 4877, + "cer": 4878, + "snapshot": 4879, + "stem": 4880, + "that a ": 4881, + "burn from ": 4882, + "{\\n /**\\n * @dev ": 4883, + "Burnable": 4884, + ".\\n *\\n * Emits a {Transfer} event ": 4885, + "division": 4886, + "WARNING: ": 4887, + "] = true": 4888, + "Interface": 4889, + "supportsInterface(interfaceId": 4890, + "call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes": 4891, + "\\n override": 4892, + "tional": 4893, + "index ": 4894, + "part ": 4895, + "tokens and ": 4896, + "tokens will be ": 4897, + "updated": 4898, + " of the contract ": 4899, + "case": 4900, + "string(": 4901, + "Shares": 4902, + "DEFAULT": 4903, + "Red": 4904, + "member": 4905, + "getAmount": 4906, + "string memory) {\\n ": 4907, + "may be ": 4908, + "grantRole": 4909, + ";\\r\\n\\r\\n ": 4910, + "directly ": 4911, + "some": 4912, + "Approval(address indexed owner, address indexed ": 4913, + "aph": 4914, + "fit into ": 4915, + "s and ": 4916, + "root": 4917, + "\\\"0": 4918, + "chain ": 4919, + "lower ": 4920, + ".\\n uint256 private constant _": 4921, + "For a ": 4922, + "ual": 4923, + "upp": 4924, + "input is ": 4925, + "ution": 4926, + "set, ": 4927, + "provid": 4928, + "isContract(": 4929, + "automatic ": 4930, + "owned by `from`.\\n * - If the caller is not `from`, it ": 4931, + "ds": 4932, + "Interface of the ": 4933, + ";\\n\\n/**\\n * @title ": 4934, + "token/ERC20/ERC20": 4935, + "AndLiquify": 4936, + "dF": 4937, + "must fit into ": 4938, + ", \\\"SafeCast: value doesn't fit in ": 4939, + "domainSeparator": 4940, + "otherwis": 4941, + "greater than largest ": 4942, + "input must fit into ": 4943, + "to a new ": 4944, + "YMB": 4945, + "al representation": 4946, + "_isExcludedMaxTransactionAmount": 4947, + "precisi": 4948, + "granted to ": 4949, + "YMBOL": 4950, + ")) {\\n ": 4951, + "ear": 4952, + "Trading": 4953, + "keccak256(\\\"": 4954, + "token/ERC20/IERC20": 4955, + "`sender": 4956, + "\\n */\\n ": 4957, + "Payment": 4958, + "price ": 4959, + "tTransferAmount": 4960, + "ower": 4961, + "owner,\\n address ": 4962, + "Revert": 4963, + "auge": 4964, + "Bl": 4965, + "from the zero address\\\");\\n require(": 4966, + "oftwa": 4967, + "Version": 4968, + "2C": 4969, + "en/": 4970, + "token1": 4971, + "optional ": 4972, + "s].\\n */\\n function _": 4973, + ";\\n // ": 4974, + "tain ": 4975, + "blockNumber": 4976, + "\\n *\\n * _Available since v4.": 4977, + "excludeFromFees": 4978, + "Overflow": 4979, + "a / result": 4980, + "`newOwner": 4981, + "transfer of ": 4982, + "system": 4983, + "Values": 4984, + "er-": 4985, + "root ": 4986, + "to the zero address\"": 4987, + "change": 4988, + "Transfer(address indexed from, address indexed to, uint256 ": 4989, + "Af": 4990, + "deposit": 4991, + "uint256, ": 4992, + "Nonexistent": 4993, + "_holderLast": 4994, + "to a new account (": 4995, + "(\\n ": 4996, + "ed\"": 4997, + "ownership of the contract ": 4998, + "expected ": 4999, + "(sender, recipient, amount": 5000, + "diffe": 5001, + " >= ": 5002, + "ven": 5003, + "probl": 5004, + "160": 5005, + "cryp": 5006, + "s. ": 5007, + "ing of ": 5008, + " = new ": 5009, + "allowance granted to ": 5010, + "\\n */\\ncontract ": 5011, + "certain ": 5012, + "_holderLastTransfer": 5013, + "once ": 5014, + "ExtraData": 5015, + "for\\n * ": 5016, + "structHash": 5017, + "`spender` by ": 5018, + "To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _": 5019, + "problems ": 5020, + "seri": 5021, + "Addition": 5022, + "with an ": 5023, + "time ": 5024, + "erations": 5025, + "OperatorFilterer": 5026, + "Atom": 5027, + "}. ": 5028, + "throw": 5029, + "extcode": 5030, + "veal": 5031, + "guide": 5032, + "Implementation of the ": 5033, + "lying ": 5034, + "_ADMIN": 5035, + "buffer[": 5036, + "move this ": 5037, + "to a new account (`newOwner": 5038, + "ownership of the contract to a new account (`newOwner": 5039, + "2 ": 5040, + "MENT": 5041, + "toUint": 5042, + "can be used as a ": 5043, + "_ENTERED": 5044, + ".\\n function ": 5045, + "\\n * ": 5046, + "whitelist": 5047, + "\\n */\\n function ": 5048, + "ETHToFee": 5049, + "Rel": 5050, + "alis": 5051, + "loc": 5052, + "multiple ": 5053, + "creases the allowance granted to ": 5054, + ");\\n ": 5055, + "}\\n return ": 5056, + "`spender` by the caller": 5057, + "ownership of the contract to a new account (`newOwner`": 5058, + "es are ": 5059, + "decimals ": 5060, + "Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function ": 5061, + "}\\n * ": 5062, + "sendETHToFee": 5063, + "later ": 5064, + "` must have a balance of at least `amount": 5065, + "ability": 5066, + "alternative to ": 5067, + "do ": 5068, + "elock": 5069, + "Root": 5070, + "RecoverError.": 5071, + "(target, data, \\\"Address: low-level ": 5072, + "merkle": 5073, + "address private ": 5074, + "{approve} that ": 5075, + "mitigation ": 5076, + "is an alternative to ": 5077, + "how-": 5078, + "Atomically ": 5079, + "can be used as a mitigation ": 5080, + "creases the allowance granted to `spender` by the caller": 5081, + "{approve} that can be used as a mitigation ": 5082, + "is an alternative to {approve} that can be used as a mitigation ": 5083, + "(which ": 5084, + "Batch": 5085, + "Cach": 5086, + "Sec": 5087, + "T ": 5088, + "Tar": 5089, + "es, ": 5090, + "account != address(0), \\\"ERC20: ": 5091, + "Return the ": 5092, + "rent ": 5093, + "\\n ) external returns (": 5094, + "\"ERC20: approve to the zero address\"": 5095, + "granted `role": 5096, + "YMBOLS": 5097, + "NonexistentToken": 5098, + "_holderLastTransferTimestamp": 5099, + "rection": 5100, + "example": 5101, + "ecrecover": 5102, + " for the ": 5103, + "\"ERC20: approve from the zero address\"": 5104, + "arithme": 5105, + "9F": 5106, + "a\\n * `": 5107, + "secon": 5108, + "https://eips.ethereum.org/EIPS/eip-165": 5109, + ".\\n // ": 5110, + "AA": 5111, + "invariant": 5112, + "element": 5113, + " the token ": 5114, + "twos": 5115, + "QueryForNonexistentToken": 5116, + "Lea": 5117, + "track": 5118, + "ONE_": 5119, + "a {Role": 5120, + "mean": 5121, + "and burning.\\n *\\n * Calling conditions:\\n *\\n * - ": 5122, + "`nonReentrant": 5123, + "MaxWallet": 5124, + "registe": 5125, + "decrement": 5126, + "BBBBBBBB": 5127, + ";\\n\\n // Mapping from ": 5128, + "set to the zero address": 5129, + "problems described in ": 5130, + ")) private ": 5131, + "name = ": 5132, + "Copy": 5133, + "Sal": 5134, + "ecess": 5135, + ") {\\n ": 5136, + "ular ": 5137, + "newNum": 5138, + "_statu": 5139, + "bits ": 5140, + ") private view returns (": 5141, + "burned.\\n * - `": 5142, + "}\\n\\n function ": 5143, + "Manager": 5144, + "net": 5145, + "pat": 5146, + "rTransferAmount": 5147, + "along ": 5148, + "Requ": 5149, + "a safe ": 5150, + "Flag": 5151, + "IZED": 5152, + ";\\r\\n\\r\\n": 5153, + "########": 5154, + "PLY": 5155, + "utils/introspection/IERC165": 5156, + "address[] calldata path": 5157, + "+ (": 5158, + "vault": 5159, + "queri": 5160, + "TransferTo": 5161, + "point ": 5162, + "interaction": 5163, + "revokeRole": 5164, + "UPPLY": 5165, + "owned by `from`.\\n * - If the caller is not `from`, it must be ": 5166, + "nc": 5167, + "ing-": 5168, + "imit ": 5169, + "totalTokens": 5170, + "clus": 5171, + "80": 5172, + "CE": 5173, + "V4": 5174, + "bpt": 5175, + "Selector": 5176, + "505": 5177, + "sources": 5178, + "}\"": 5179, + "es for ": 5180, + "display": 5181, + "required by the ": 5182, + "on behalf ": 5183, + "\"abi": 5184, + "\"Solidity": 5185, + "\"setting": 5186, + "\"output": 5187, + "\"language": 5188, + "\"sources": 5189, + "IERC": 5190, + "}\\n }\\n\\n ": 5191, + "thed": 5192, + "bytecode\"": 5193, + " = 1": 5194, + ") {\\n if (": 5195, + "ized ": 5196, + "Selection": 5197, + "readthed": 5198, + "ocs.io/": 5199, + "Bytecode\"": 5200, + "izer\"": 5201, + "\"evm.deployed": 5202, + "\"evm.bytecode\"": 5203, + "\"abi\"": 5204, + "\"Solidity\"": 5205, + "\"settings\"": 5206, + "\"outputSelection": 5207, + "\"language\"": 5208, + "\"sources\"": 5209, + "readthedocs.io/": 5210, + "\"evm.deployedBytecode\"": 5211, + "\"outputSelection\"": 5212, + "readthedocs.io/en/": 5213, + " // ": 5214, + "\"optim": 5215, + "\"run": 5216, + "\"enabled\"": 5217, + "Lp": 5218, + "`.\\n */\\n function _": 5219, + "values are ": 5220, + "more": 5221, + "TokenOwnership ": 5222, + "IERC721Receiver-onERC721Received}, which is called upon ": 5223, + "a safe transfer": 5224, + "\"optimizer\"": 5225, + "\"runs\"": 5226, + "IERC721Receiver-onERC721Received}, which is called upon a safe transfer": 5227, + "by default": 5228, + "used for ": 5229, + "1155": 5230, + "aling ": 5231, + "Exit": 5232, + "EnumerableSet": 5233, + "reentranc": 5234, + "Im": 5235, + "\\n if (": 5236, + "\\\");\\n }\\n\\n /**\\n * @dev ": 5237, + "onlyOwner {\\n require(": 5238, + "URNED": 5239, + "() public ": 5240, + "  ": 5241, + "buyLiquidityFee": 5242, + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n ": 5243, + "set._inner, ": 5244, + "(\\n ": 5245, + "ization": 5246, + "scalingFactor": 5247, + "_exists(tokenId": 5248, + "' ": 5249, + "hel": 5250, + "accountBalance ": 5251, + "transferDelay": 5252, + "successful": 5253, + "store": 5254, + "appli": 5255, + "Extension": 5256, + "sent": 5257, + "token0": 5258, + "Owner(": 5259, + ".\\n *\\n * See {": 5260, + "ETHFor": 5261, + "_allowances[": 5262, + ") internal view returns (bool": 5263, + "additional ": 5264, + "https://github.com/ethereum": 5265, + "Slot ": 5266, + " ": 5267, + ";\\n if (": 5268, + "ETH ": 5269, + "srcRep": 5270, + "full": 5271, + "90": 5272, + "shr": 5273, + "IERC165 {\\n /**\\n * @dev ": 5274, + "collection ": 5275, + "caller is not the owner\"": 5276, + ")\"": 5277, + "via {": 5278, + "transfer}": 5279, + "number ": 5280, + "Pool ": 5281, + "Author": 5282, + "divisor ": 5283, + "laun": 5284, + ")\\n public": 5285, + "API": 5286, + "utils/introspection/ERC165": 5287, + ")\\n // ": 5288, + ".call{": 5289, + "would ": 5290, + "blacklist": 5291, + "lockThe": 5292, + "lockTheSwap": 5293, + "ded": 5294, + "e it ": 5295, + "ate the ": 5296, + ", _data": 5297, + "lab": 5298, + "that": 5299, + "\\n\\n// ": 5300, + ", uint256 index": 5301, + "33333333": 5302, + "\"Ownable: caller is not the owner\"": 5303, + "AG": 5304, + "function to ": 5305, + "called": 5306, + "eth_": 5307, + "Member": 5308, + ");\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`": 5309, + "clusi": 5310, + " {": 5311, + "lect": 5312, + "}\\n }\\n}\\n\"": 5313, + "For example": 5314, + "uce ": 5315, + "contracts-": 5316, + "msg.sender == ": 5317, + "owned ": 5318, + "BITMASK_ADDRESS": 5319, + "` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into ": 5320, + "reverting on\\n * overflow (when the input is ": 5321, + "isContract(target": 5322, + " L": 5323, + "metadata ": 5324, + "tra ": 5325, + "), \\\"Address: ": 5326, + ";\\r\\n }\\r\\n\\r\\n function ": 5327, + "isContract(target), \\\"Address: ": 5328, + "FE": 5329, + "Join": 5330, + "necess": 5331, + ".safe": 5332, + "leaves ": 5333, + ") public view virtual override returns (uint256) {\\n return ": 5334, + ");\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * ": 5335, + "739": 5336, + "wallet ": 5337, + "ERC721.": 5338, + "operator ": 5339, + ".\\n *\\n * _Available since v4.": 5340, + "zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _": 5341, + "Contract modul": 5342, + " F": 5343, + "_un": 5344, + "ough ": 5345, + ",\\n address to,\\n ": 5346, + "super._": 5347, + "User": 5348, + "owner of the ": 5349, + "moved ": 5350, + "}\\n}\\n\"": 5351, + ") public virtual returns (bool) {\\n ": 5352, + ");\\n return true;\\n }\\n\\n /**\\n * @dev ": 5353, + "normal": 5354, + "Down": 5355, + "want": 5356, + "IERC721A": 5357, + "assets": 5358, + "fallback ": 5359, + "easi": 5360, + "EV": 5361, + "PP": 5362, + "realis": 5363, + "es.": 5364, + "in packed ": 5365, + "_taxFee": 5366, + "Addr": 5367, + "a contract.\\n *\\n * ": 5368, + "mapping (address => ": 5369, + "bene": 5370, + "reak": 5371, + "))\\n ": 5372, + "remove ": 5373, + "DEFAULT_ADMIN": 5374, + "gg": 5375, + "iction": 5376, + "_owner = ": 5377, + "Returns an ": 5378, + "KKKKKKKK": 5379, + "amount exceeds allowance\"": 5380, + "for (uint256 i = 0; i < ": 5381, + "3.0": 5382, + ") public virtual override {\\n ": 5383, + "address(this).balance ": 5384, + "App": 5385, + "da": 5386, + "order ": 5387, + "\\\":": 5388, + "most ": 5389, + "Provides ": 5390, + "), \\\"ERC721: ": 5391, + "such a ": 5392, + "query for ": 5393, + ":\\n *": 5394, + " of `": 5395, + "rounding": 5396, + "& 0x": 5397, + "issues/": 5398, + "DEFAULT_ADMIN_ROLE": 5399, + "Y ": 5400, + "[_": 5401, + "br": 5402, + "ading ": 5403, + "roll": 5404, + " = 2": 5405, + "LEMENT": 5406, + "list ": 5407, + "▒▒": 5408, + "tokenIndex": 5409, + "Valid": 5410, + "graph": 5411, + "s[i]": 5412, + "multip": 5413, + "` is zero, `tokenId` ": 5414, + "(owner": 5415, + "ed. ": 5416, + "context": 5417, + ";\\n _": 5418, + "OperatorFilter": 5419, + "mask": 5420, + "enal": 5421, + "ified": 5422, + "Deposit": 5423, + "RoyaltyInfo": 5424, + "crypto": 5425, + "];\\n }\\n\\n /**\\n * @dev See {IERC20-": 5426, + "` as a ": 5427, + "will be\\n * ": 5428, + "ER_ROLE": 5429, + ");\\n }\\n\\n /**\\n * @dev Returns the downcasted ": 5430, + "result = (": 5431, + "PL-": 5432, + "Second": 5433, + "NS": 5434, + "gin": 5435, + " */": 5436, + "que": 5437, + "Revert ": 5438, + "accounts ": 5439, + " = 0x": 5440, + ".sol\\\";\\nimport \\\"../": 5441, + "functionCallWithValue(target, data": 5442, + "uint32 ": 5443, + "bytes calldata data": 5444, + "meta": 5445, + "ing the\\n * ": 5446, + "two": 5447, + "_SUPPLY": 5448, + "PERMIT": 5449, + "multiplication ": 5450, + "_tokenApprovals[tokenId": 5451, + "extcodesize": 5452, + "01": 5453, + "DOMAIN_SEPARATOR": 5454, + "0.7": 5455, + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./": 5456, + "al representation.\\n */\\n function ": 5457, + "Limits": 5458, + "exist ": 5459, + "`account` ": 5460, + "burned.\\n * - `from` and `to` are never both ": 5461, + "/* ": 5462, + "_remove": 5463, + "adecim": 5464, + "ateg": 5465, + "creator": 5466, + "and\\n * ": 5467, + "assert": 5468, + "@openzeppelin/": 5469, + "result + ": 5470, + "hexadecim": 5471, + "a / result) >> ": 5472, + "result = (result + ": 5473, + "result = (result + a / result) >> ": 5474, + "super.supportsInterface(interfaceId": 5475, + ",\\\"": 5476, + "a25": 5477, + "b4c": 5478, + ") external onlyOwner {\\n ": 5479, + "Operations": 5480, + "more than ": 5481, + "\"@": 5482, + "ret": 5483, + ": 0": 5484, + "totalSupply() external view returns (uint256": 5485, + "age of ": 5486, + ");\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-": 5487, + "+ b": 5488, + "Ethereum": 5489, + "ww": 5490, + "_inner": 5491, + "30B": 5492, + "contains(": 5493, + "_approve(owner, spender, ": 5494, + "free ": 5495, + "char": 5496, + "All ": 5497, + "taken": 5498, + ".\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address": 5499, + "can be used to\\n * ": 5500, + "can be used to\\n * e.g. ": 5501, + "compu": 5502, + "\\n // ": 5503, + "Quant": 5504, + "_operatorApproval": 5505, + "redeem": 5506, + ".\\n *\\n * Emits a {Transfer} event with ": 5507, + "`)": 5508, + "sending ": 5509, + "88D": 5510, + "total supply.\\n *\\n * Emits a {Transfer} event with ": 5511, + "SafeERC20": 5512, + "⠀⠀⠀⠀": 5513, + "cannot overflow": 5514, + "INITIALIZED": 5515, + "name of the token": 5516, + ") <= ": 5517, + "Code": 5518, + "private constant _": 5519, + "starting ": 5520, + "2488D": 5521, + "_SYMBOLS": 5522, + "Acb4c": 5523, + "39739": 5524, + "5630B": 5525, + "4cF5": 5526, + "659F": 5527, + "5dAcb4c": 5528, + "0d5630B": 5529, + "dF2C": 5530, + "a250d5630B": 5531, + "39739dF2C": 5532, + "4cF539739dF2C": 5533, + "659F2488D": 5534, + "5dAcb4c659F2488D": 5535, + "a250d5630B4cF539739dF2C": 5536, + "a250d5630B4cF539739dF2C5dAcb4c659F2488D": 5537, + "9a": 5538, + "too ": 5539, + "post": 5540, + ");\\n }\\n\\n /**\\n * @dev Destroy": 5541, + "ed to a ": 5542, + "uint16 ": 5543, + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n return ": 5544, + "v2-": 5545, + "specified ": 5546, + "/2": 5547, + "eres": 5548, + "s in ": 5549, + "under": 5550, + "erflow": 5551, + " << ": 5552, + "S ": 5553, + " ": 5554, + "symbol of the token": 5555, + ".\\n *\\n * This is an alternative to {approve} that can be used as a mitigation ": 5556, + "(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ": 5557, + "creases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation ": 5558, + "problems described in {IERC20-approve}": 5559, + "creases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * ": 5560, + "ing for ": 5561, + "Stak": 5562, + "mstore(0x": 5563, + "global": 5564, + ".\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function ": 5565, + "(hash": 5566, + ",\\n ": 5567, + "edHash": 5568, + "`, which ": 5569, + "Emitted when the ": 5570, + "Fungi": 5571, + "(x, ": 5572, + "problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance": 5573, + "creases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance": 5574, + ")) ": 5575, + "Treasury": 5576, + "under ": 5577, + ") return (": 5578, + "if(": 5579, + "sender (": 5580, + "\\n\\npragma solidity ^0.8.": 5581, + "(from, to, amount": 5582, + "transferDelayEnabled": 5583, + "() public view virtual returns (": 5584, + "had": 5585, + "edData": 5586, + "and not ": 5587, + "beha": 5588, + "0, errorMessage": 5589, + "OR ": 5590, + "Hook that is called before ": 5591, + "pattern": 5592, + "if `": 5593, + "OfOwner": 5594, + "TokensSupportingFeeOnTransferTokens": 5595, + " bits ": 5596, + "delegatec": 5597, + "\\r\\n /**\\r\\n * @dev Returns the ": 5598, + "utils/Context.sol\\\";\\n\\n/**\\n * @dev ": 5599, + "\\n view\\n returns (": 5600, + "(address account, uint256 amount) internal virtual {\\n require(": 5601, + "cryptograph": 5602, + "& _": 5603, + "ring ": 5604, + "onlyAllowed": 5605, + "any transfer of ": 5606, + "Royal": 5607, + ";\\n\\n emit Transfer": 5608, + "currentAllowance = ": 5609, + "QU": 5610, + "Wallet ": 5611, + "[tokenId": 5612, + "✓✓": 5613, + "/**\\n * ": 5614, + ";\\n\\n ": 5615, + "this function": 5616, + ", \\\"SafeMath: ": 5617, + ") internal view returns (bytes memory": 5618, + "mapping(address => bool": 5619, + "implement {": 5620, + "Collateral": 5621, + "token/ERC721/extensions/": 5622, + "];\\n ": 5623, + "cach": 5624, + "\\n // - ": 5625, + ";\\n }\\n\\n /**\\n * @notice ": 5626, + "p3) internal view {\\n\\t\\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature(\\\"log(": 5627, + "If `to` refers to a smart contract, it must implement {": 5628, + "behavi": 5629, + "LOT": 5630, + "now": 5631, + "= 2": 5632, + "contractETHBalance": 5633, + "this\\n * function ": 5634, + "tokens. This include": 5635, + "set of ": 5636, + "intermedi": 5637, + "returndata_size": 5638, + "(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: ": 5639, + "any transfer of tokens. This include": 5640, + ".\\r": 5641, + "License ": 5642, + "}.\\n * ": 5643, + ")\\\", p0, p1, p2, p3));\\n\\t\\tignored;\\n\\t}\\n\\n\\tfunction ": 5644, + "FFFFFFFFFFFFFFFF": 5645, + "dstRep": 5646, + "restriction": 5647, + "Target": 5648, + "FeePercentage": 5649, + "team": 5650, + "Errors.": 5651, + "Ethereum ": 5652, + "datas": 5653, + "length ": 5654, + "string memory name_": 5655, + "delegator": 5656, + "ATIONS": 5657, + "deduc": 5658, + "NSF": 5659, + "ensi": 5660, + "the actual ": 5661, + "IERC721Enumerable": 5662, + "Update": 5663, + "}\\n }\\n ": 5664, + "Enumeration": 5665, + "`recipient": 5666, + "well": 5667, + "ite ": 5668, + "reduce ": 5669, + "ether": 5670, + "ApprovedOrOwner": 5671, + "Role(role, account": 5672, + "EXT_": 5673, + ".0) (utils/": 5674, + "░░░░░░░░": 5675, + "computedHash": 5676, + ".readthedocs.io/en/": 5677, + "infin": 5678, + "und": 5679, + "role].": 5680, + "Numerator": 5681, + "solidity.readthedocs.io/en/": 5682, + "(int256 ": 5683, + "));\\n ": 5684, + "7._\\n */\\n function ": 5685, + "UMB": 5686, + "ving ": 5687, + "Approve ": 5688, + "with a ": 5689, + "uint p1": 5690, + "p0, uint p1": 5691, + "-supportsInterface": 5692, + "Vault ": 5693, + "_liquidityFee": 5694, + "//\\n // ": 5695, + "a + b": 5696, + "uration": 5697, + "IERC165-supportsInterface": 5698, + "uint64 ": 5699, + "extern": 5700, + "32, ": 5701, + "code.length": 5702, + "bool public ": 5703, + "(\\n address owner,\\n address ": 5704, + "(\\r\\n address ": 5705, + "be an ": 5706, + " of {": 5707, + "this is ": 5708, + "revert (": 5709, + "(data);\\n return verifyCallResult": 5710, + ";\\n}\\n\"": 5711, + "pragma solidity ^0.8.": 5712, + "sellMarketingFee": 5713, + "\"dev": 5714, + "buil": 5715, + "Optional": 5716, + "https://solidity.readthedocs.io/en/": 5717, + "will be the ": 5718, + ", including ": 5719, + ") internal returns (bytes memory) {\\n return functionCallWithValue(target, data": 5720, + "burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _": 5721, + "70": 5722, + "\\n * @return ": 5723, + "red by ": 5724, + "_msgSender() internal view virtual returns (": 5725, + "generally ": 5726, + "ratio": 5727, + "precision": 5728, + ");\\n }": 5729, + "zero.\\n */\\n function ": 5730, + "Emits an {Approval": 5731, + "_symbol = ": 5732, + "increas": 5733, + ";\\n emit Approval": 5734, + "result = (result + a / result) >> 1;\\n ": 5735, + "Wrapp": 5736, + "s = _": 5737, + "unsafe ": 5738, + "separator": 5739, + "at a ": 5740, + "}.\\n *\\n * ": 5741, + "erkle ": 5742, + "author ": 5743, + "interfaces/I": 5744, + "string private _name": 5745, + "set. O(1).\\n *\\n * ": 5746, + "approved to ": 5747, + "bi": 5748, + "replac": 5749, + "alloc": 5750, + "and be ": 5751, + "decimals} ": 5752, + "BITPOS_NUMB": 5753, + ".safeTransfer": 5754, + "EXT_INITIALIZED": 5755, + "BITPOS_NUMBER_": 5756, + "TOKEN": 5757, + "[i]": 5758, + "\\n require(": 5759, + "ick": 5760, + "0 ? ": 5761, + "sible ": 5762, + "address,address,": 5763, + "totalTokensToSwap": 5764, + ".\\n // ": 5765, + "ance ": 5766, + "expensi": 5767, + "\"ERC20: transfer amount exceeds allowance\"": 5768, + "76": 5769, + "accounts": 5770, + "token by either {approve} or {setApprovalForAll": 5771, + "codeHash": 5772, + "current owner": 5773, + "Ether ": 5774, + "It is ": 5775, + "TypedData": 5776, + "information about ": 5777, + "'s\\n * ": 5778, + "t = ": 5779, + "rect ": 5780, + "AddressSet": 5781, + "may not be ": 5782, + "admin role": 5783, + "== 0) {\\n return ": 5784, + "();\\n\\n /**\\n * The ": 5785, + "-like ": 5786, + "}\\n }\\n\\n function ": 5787, + "toInt": 5788, + "must exist ": 5789, + ");\\n\\n /**\\n * @notice ": 5790, + "\\r\\n *\\r": 5791, + "`.\\n *\\n * This ": 5792, + ".\\n */\\n event Transfer(address indexed from, address indexed to, uint256 ": 5793, + "unchecked {\\n // ": 5794, + "call to non-contract\\\");\\n\\n ": 5795, + "must exist and be ": 5796, + "(success, returndata, errorMessage": 5797, + "IST": 5798, + "nCheckpoint": 5799, + "}\\n\\n /**\\n * @dev ": 5800, + "the expected ": 5801, + ";\\n\\n event ": 5802, + "emitted ": 5803, + "ed to be ": 5804, + "s[account": 5805, + "ed by `": 5806, + " != 0": 5807, + ");\\r\\n\\r\\n function ": 5808, + ");\\n }\\n\\n // ": 5809, + "signatures": 5810, + "E ": 5811, + "es\"": 5812, + "ing `": 5813, + "override {\\n ": 5814, + "_SLOT": 5815, + "_balances[from": 5816, + "Initializes the contract ": 5817, + "-f": 5818, + "HEX": 5819, + ", uint amount": 5820, + "dealing ": 5821, + ".\\n *\\n * NOTE: ": 5822, + "and-": 5823, + "userData": 5824, + "reserve1": 5825, + "dealing with ": 5826, + ";\\n function ": 5827, + "ate, ": 5828, + "positive ": 5829, + "; i++) {\\n ": 5830, + "afely transfers ": 5831, + "OptionalReturn": 5832, + "Den": 5833, + "clea": 5834, + "ed).": 5835, + "address, ": 5836, + "can only be ": 5837, + "when dealing with ": 5838, + ",\\n uint256 amount\\n ": 5839, + "they are ": 5840, + "(address(this), ": 5841, + "afely transfers `tokenId` token from `from` to `to": 5842, + "let": 5843, + "when `to": 5844, + "should not be ": 5845, + "string private _symbol": 5846, + "filtered": 5847, + "` and `to` are both non-zero, `amount` ": 5848, + "`nonReentrant` ": 5849, + "multiplication overflow": 5850, + "when `to` is zero, `amount` ": 5851, + "\"user": 5852, + "() public view returns (": 5853, + "x ": 5854, + "cally ": 5855, + ".\\n */\\n event Approval(address indexed owner, address indexed ": 5856, + "MAX_": 5857, + "\"devdoc\"": 5858, + "\"userdoc\"": 5859, + "callOptionalReturn": 5860, + "lize": 5861, + "true, ": 5862, + "} event.\\n *\\n * Requirements:\\n *\\n * - `": 5863, + "NotOwner": 5864, + ");\\n }\\n\\n function _": 5865, + "Collection": 5866, + "Bas": 5867, + "ET": 5868, + "owner() ": 5869, + "newAmount": 5870, + "nonexistent": 5871, + "block ": 5872, + "Uniswap": 5873, + "5555": 5874, + ".mul(": 5875, + "IAccessControl": 5876, + "Power": 5877, + "b;\\n }\\n\\n /**\\n * @dev Returns the ": 5878, + ", either ": 5879, + "add(32, ": 5880, + ", uint p2": 5881, + "`tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist": 5882, + "when `from` is zero, `amount` ": 5883, + "when `from` and `to` are both non-zero, `amount` ": 5884, + "tx.or": 5885, + "ally-owned ": 5886, + "set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `": 5887, + "divisor cannot be ": 5888, + "externally-owned ": 5889, + "`tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ": 5890, + "));\\n }\\n\\n /**\\n * @dev ": 5891, + "dest": 5892, + "1884": 5893, + "can be appli": 5894, + "numberMinted": 5895, + "umulative": 5896, + "))\\n ": 5897, + "changing ": 5898, + "chainId": 5899, + "an address where ": 5900, + "_msgData() internal view virtual returns (": 5901, + "an address where a contract ": 5902, + ", they ": 5903, + "active": 5904, + "exempt": 5905, + "vider": 5906, + ") {\\r\\n ": 5907, + "an externally-owned ": 5908, + "checks-": 5909, + "URI for ": 5910, + "balance for ": 5911, + "voting ": 5912, + ".\\n *\\n * Emits a {Transfer} event.\\n */\\n function _": 5913, + "s-interaction": 5914, + "effects-interaction": 5915, + "checks-effects-interaction": 5916, + "(uint256(": 5917, + "revok": 5918, + "returns ": 5919, + "tokens\\n * ": 5920, + "].sub(": 5921, + "uint96 ": 5922, + ",\\n bytes memory _data": 5923, + "Quantity": 5924, + "2,\\n ": 5925, + "quantity` ": 5926, + "_init": 5927, + "perform ": 5928, + "minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - ": 5929, + "concern": 5930, + "smallest ": 5931, + ";\\n }": 5932, + "squ": 5933, + "ERC721Enumerable": 5934, + "ement for ": 5935, + "prod1 ": 5936, + "\\n /// @return ": 5937, + " - denominator * ": 5938, + ", string memory symbol_": 5939, + "; // inverse ": 5940, + "get the ": 5941, + "} else {\\n ": 5942, + "s\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - ": 5943, + ");\\r\\n }\\r\\n\\r\\n function ": 5944, + "Librar": 5945, + "exceed ": 5946, + "PERMIT_TYPEHASH": 5947, + "= 2 - denominator * ": 5948, + "any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - ": 5949, + "string memory name_, string memory symbol_": 5950, + "; // inverse mod ": 5951, + "far ": 5952, + "nft": 5953, + "ank": 5954, + ") {\\n ": 5955, + "pragma solidity ^0.8.0": 5956, + "different ": 5957, + "VAL": 5958, + "free": 5959, + " to be transferred": 5960, + "delegatecall": 5961, + "If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer": 5962, + "datasize": 5963, + "mit ": 5964, + "desi": 5965, + "ument": 5966, + "not\\n * ": 5967, + "\\u003c": 5968, + "such as ": 5969, + "MMMMMMMMMMMMMMMM": 5970, + "_000_000": 5971, + "execution context": 5972, + "Ren": 5973, + "_setup": 5974, + "functions to ": 5975, + "iszero": 5976, + "when `target` revert": 5977, + "address(this), ": 5978, + "these are ": 5979, + "SION": 5980, + "amountTo": 5981, + ") {\\n ": 5982, + " is Context": 5983, + "``owner": 5984, + "While ": 5985, + "xx": 5986, + "\\\" ": 5987, + "senderBalance": 5988, + "correct ": 5989, + "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D": 5990, + "ft ": 5991, + "sti": 5992, + "aid ": 5993, + "ATUR": 5994, + "possible": 5995, + ") internal view returns (uint256) {\\n return ": 5996, + "required for ": 5997, + "revert reason when `target` revert": 5998, + "fallback revert reason when `target` revert": 5999, + "-transaction": 6000, + "random": 6001, + "tist": 6002, + "} interface": 6003, + "nonce ": 6004, + "meta-transaction": 6005, + "IERC165-supportsInterface}.\\n */\\n function ": 6006, + "[msg.sender": 6007, + "_ownedTokens": 6008, + "side ": 6009, + "approve(address to, uint256 tokenId": 6010, + "other than ": 6011, + "in the EIP": 6012, + ";\\n }\\n return ": 6013, + "CallerNotOwner": 6014, + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically ": 6015, + "``owner``'s ": 6016, + "as `": 6017, + "value <= ": 6018, + "errorMessage` as a ": 6019, + "errorMessage` as a fallback revert reason when `target` revert": 6020, + ").\\n */\\n function ": 6021, + "cour": 6022, + "execut": 6023, + "0.6.": 6024, + "control ": 6025, + "name = name_": 6026, + "name of the token.\\n */\\n function name": 6027, + "Ent": 6028, + "Nor": 6029, + ",\\n bool ": 6030, + "token collection ": 6031, + "msg.sender and ": 6032, + ", \\\"Address: insufficient ": 6033, + "Current": 6034, + "Throws if ": 6035, + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be ": 6036, + "labs/": 6037, + "retval": 6038, + "NorApproved": 6039, + "TER": 6040, + "gauge": 6041, + "ed (": 6042, + " of the transaction": 6043, + "V3": 6044, + "_b": 6045, + "balanceOf(address owner": 6046, + ") private {\\n ": 6047, + "during ": 6048, + "OPERATIONS": 6049, + "Implementation of the {": 6050, + "RecoverError.InvalidSignature": 6051, + "cryptography/": 6052, + "CallerNotOwnerNorApproved": 6053, + "propos": 6054, + "address(0), tokenId": 6055, + "existence": 6056, + "malle": 6057, + "address) {\\n return msg.sender": 6058, + "information about the current ": 6059, + "when `to` is zero, `amount` of ``from``'s ": 6060, + "to != address(0), \\\"": 6061, + ");\\n\\n ": 6062, + "sender of the transaction": 6063, + "onlyOwner(": 6064, + "WithSelector": 6065, + "_msgSender(), \\\"": 6066, + " and its ": 6067, + "Asset": 6068, + "contract is only ": 6069, + "reduce the ": 6070, + ",\\n bytes memory _data\\n ": 6071, + "-26": 6072, + "paying for ": 6073, + "ed in such a ": 6074, + "accessed in such a ": 6075, + "msg.data, they ": 6076, + "via msg.sender and ": 6077, + "data. While ": 6078, + "Provides information about the current ": 6079, + "generally available": 6080, + "_symbol = symbol_": 6081, + "should not be accessed in such a ": 6082, + "execution context, including ": 6083, + "these are generally available": 6084, + "sender of the transaction and its ": 6085, + "msg.data, they should not be accessed in such a ": 6086, + "via msg.sender and msg.data, they should not be accessed in such a ": 6087, + "data. While these are generally available": 6088, + "Provides information about the current execution context, including ": 6089, + "sender of the transaction and its data. While these are generally available": 6090, + "via msg.sender and msg.data, they should not be accessed in such a direct": 6091, + "*= 2 - denominator * ": 6092, + "`'s ": 6093, + "function call": 6094, + "is concern": 6095, + "` from ": 6096, + "Ref": 6097, + "s the account ": 6098, + "as far ": 6099, + "value was ": 6100, + "indexed tokenId": 6101, + "since when dealing with ": 6102, + "manner, ": 6103, + "library-like ": 6104, + "inverse *= 2 - denominator * ": 6105, + "execution may not be ": 6106, + "\\n * - an address where a contract ": 6107, + "as an application": 6108, + "inverse; // inverse mod ": 6109, + "sender (as far ": 6110, + "intermediate, ": 6111, + "the actual sender (as far ": 6112, + "required for intermediate, ": 6113, + "meta-transactions the account ": 6114, + "contract is only required for intermediate, ": 6115, + "paying for execution may not be ": 6116, + "is concerned).": 6117, + "manner, since when dealing with ": 6118, + "library-like contracts.": 6119, + "inverse *= 2 - denominator * inverse; // inverse mod ": 6120, + "the actual sender (as far as an application": 6121, + "meta-transactions the account sending ": 6122, + "contract is only required for intermediate, library-like contracts.": 6123, + "paying for execution may not be the actual sender (as far as an application": 6124, + "\"ERC721: ": 6125, + "_fee": 6126, + "i/": 6127, + "out of ": 6128, + ".\\n *\\n * _Available since v3.1._\\n */\\n function functionCall": 6129, + ".\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue": 6130, + "against ": 6131, + "nonexistent token": 6132, + "Must ": 6133, + "No": 6134, + "ci": 6135, + "neg": 6136, + "test": 6137, + "\\n virtual": 6138, + "Max ": 6139, + "numbers": 6140, + "(uint256 tokenId) public view virtual override returns (": 6141, + ", bool approved": 6142, + "approval is ": 6143, + "when `from` and `to` are both non-zero, `amount` of ``from``'s ": 6144, + ".\\n *\\n * The ": 6145, + "in existence": 6146, + "forward": 6147, + "revert(\\\"": 6148, + "_ST": 6149, + "_allowed": 6150, + "e\\n * ": 6151, + "\\\";\\n ": 6152, + "\\r\\n ": 6153, + "chil": 6154, + "short": 6155, + "`account` is ": 6156, + "\\n * ": 6157, + "errorMessage` as a fallback revert reason when `target` reverts": 6158, + "in\\n * ": 6159, + "ves the ": 6160, + "abs": 6161, + "0 if ": 6162, + "OwnershipTransferred(": 6163, + "Rounding ": 6164, + "copy ": 6165, + "(account, address(0), amount);\\n\\n ": 6166, + ",\\n address to,\\n uint deadline": 6167, + "onlyAllowedOperator": 6168, + "(\\n address owner,\\n address spender": 6169, + "\"librari": 6170, + "ber ": 6171, + "mapping(address => uint256) private ": 6172, + "isExcludedFrom": 6173, + "approved to move this ": 6174, + "ion": 6175, + "payload": 6176, + "IUniswapV2Pair": 6177, + "opcode to ": 6178, + "(address(0), account, amount);\\n\\n ": 6179, + "ensure": 6180, + ") internal returns (bytes memory) {\\n return functionCallWithValue(target, data, ": 6181, + "\"libraries\"": 6182, + "-name": 6183, + "Uri": 6184, + "us ": 6185, + "xy ": 6186, + "\\n *": 6187, + "ouched": 6188, + "icit": 6189, + "newImplementation": 6190, + "0xdead": 6191, + "domain ": 6192, + "changed ": 6193, + "gas unt": 6194, + "{\\r\\n require(": 6195, + "remaining gas unt": 6196, + "opcode (which ": 6197, + "Context {\\n function ": 6198, + "leaves remaining gas unt": 6199, + "PL-3.0": 6200, + "ouched) ": 6201, + "opcode (which leaves remaining gas unt": 6202, + "opcode (which leaves remaining gas untouched) ": 6203, + "1;\\n ": 6204, + "92": 6205, + ") - 1": 6206, + "buffer = new ": 6207, + "Implementer": 6208, + "() external pure returns (": 6209, + "invalid opcode to ": 6210, + "remaining gas": 6211, + "consuming all ": 6212, + "revert (consuming all ": 6213, + "tx.origin": 6214, + "opcode (which leaves remaining gas untouched) while ": 6215, + "invalid opcode to revert (consuming all ": 6216, + "invalid opcode to revert (consuming all remaining gas": 6217, + "bit": 6218, + "ep": 6219, + "eem": 6220, + "| ": 6221, + "ERC20Permit": 6222, + " * length": 6223, + "Reserve": 6224, + "upper ": 6225, + "behavior ": 6226, + "Context {\\n function _msgSender() internal view virtual returns (": 6227, + "Edition": 6228, + "token.": 6229, + "\\n * https://": 6230, + ");\\n\\n if (": 6231, + "implementer": 6232, + "ONE": 6233, + "Enabl": 6234, + "revert reason": 6235, + "\"Address: low-level ": 6236, + ". The result is ": 6237, + "transferred to `to`.\\n * - when `from` is zero, `amount` ": 6238, + "aver": 6239, + "dexRouter": 6240, + "Inf": 6241, + "newWallet": 6242, + "See {IERC20-": 6243, + ");\\n\\n /**\\n * @dev Returns the amount of tokens ": 6244, + "IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual ": 6245, + "NG": 6246, + "ose ": 6247, + "s\\n ": 6248, + ". We ": 6249, + "192": 6250, + "Does not ": 6251, + ", r, s": 6252, + "manage all": 6253, + "alway": 6254, + "section": 6255, + "tokens of ": 6256, + "can be used to ": 6257, + "startTokenId ": 6258, + "owner, spender": 6259, + "amountTokenDesired": 6260, + "whenNotPaused": 6261, + "address owner = _msgSender();\\n ": 6262, + "} interface.\\n *\\n * ": 6263, + "68": 6264, + "ln": 6265, + "ent ": 6266, + "assign": 6267, + "override(": 6268, + ";\\n }\\n\\n function _msgData() internal view virtual returns (": 6269, + "at(": 6270, + "it to ": 6271, + "prot": 6272, + "bytes calldata": 6273, + "latest": 6274, + "Fee = ": 6275, + "allowance(owner, spender": 6276, + "Request": 6277, + "Cle": 6278, + "Decim": 6279, + "_rol": 6280, + "\\n return ": 6281, + "TokenURI": 6282, + "ll ": 6283, + "\\n * via msg.sender and msg.data, they should not be accessed in such a direct": 6284, + "the calling ": 6285, + "Look": 6286, + "discour": 6287, + ".\\n */\\nlibrary ": 6288, + "the\\n * sender of the transaction and its data. While these are generally available": 6289, + "Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available": 6290, + "\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * ": 6291, + "discourag": 6292, + "Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * ": 6293, + "1)": 6294, + "2, ": 6295, + "VR": 6296, + "isting ": 6297, + "caller": 6298, + "\\n * is concerned).": 6299, + "token id": 6300, + "can call ": 6301, + "changes ": 6302, + ");\\n }\\n\\n /**": 6303, + "_redisFee": 6304, + "call.\\n *\\n * _Available since v3.3._\\n */\\n function ": 6305, + "\\n *\\n * This contract is only required for intermediate, library-like contracts.": 6306, + "GNU General Public License ": 6307, + "and\\n * paying for execution may not be the actual sender (as far as an application": 6308, + "meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application": 6309, + "Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with ": 6310, + "\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.": 6311, + "meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.": 6312, + "editionId": 6313, + ".sub(": 6314, + ", which is ": 6315, + "version ": 6316, + "that the ": 6317, + "beare": 6318, + "IERC20 token": 6319, + "Requirements:\\r\\n *\\r": 6320, + "static call.\\n *\\n * _Available since v3.3._\\n */\\n function ": 6321, + "-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function ": 6322, + "positive value": 6323, + "value <= type(": 6324, + "-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall": 6325, + "functional": 6326, + " = (": 6327, + "for an ": 6328, + "`.\\n ": 6329, + "`, emits ": 6330, + "denominator ": 6331, + "there are ": 6332, + "query for nonexistent token": 6333, + "`, emits a {Role": 6334, + "uniswap": 6335, + "` with ": 6336, + "msb": 6337, + "direction": 6338, + ", uint256 _": 6339, + "0 and ": 6340, + "Calcul": 6341, + "Distribu": 6342, + "r,\\n bytes32 ": 6343, + "update the ": 6344, + "false, 0": 6345, + ",\\n bytes32 r,\\n bytes32 ": 6346, + "false ": 6347, + "1._": 6348, + "s {\\n ": 6349, + "` will ": 6350, + "log in ": 6351, + "pragma solidity 0.8.": 6352, + "Returns 0 if ": 6353, + "regular ": 6354, + "Counters": 6355, + "position ": 6356, + "ERC721Receiver ": 6357, + "Converts a `uint256` to its ASCII `string` hexadecim": 6358, + "Return the log in ": 6359, + "meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ": 6360, + "Returns 0 if given ": 6361, + "Return the log in base ": 6362, + ";\\r\\n ": 6363, + "GIST": 6364, + "Ptr": 6365, + "minting": 6366, + "ected ": 6367, + "receive ": 6368, + "REGIST": 6369, + ", of a ": 6370, + "provide": 6371, + "from the caller": 6372, + "value = ": 6373, + "_approve(_msgSender(), ": 6374, + ".\\n * The ": 6375, + "method": 6376, + "EEEE": 6377, + ").max, \\\"SafeCast: value doesn't fit in ": 6378, + "program is ": 6379, + "eq": 6380, + "an allowance ": 6381, + "setFee": 6382, + "create ": 6383, + "operator, ": 6384, + "] + ": 6385, + ";\\n }\\n\\n /**\\n * @dev See {IERC721-": 6386, + "tradingActive": 6387, + "Redeem": 6388, + ".call{value: ": 6389, + "OPERATIONS\\n // =============================================================\\n\\n /**\\n * @dev ": 6390, + ", of a positive value": 6391, + "Hel": 6392, + "255": 6393, + "red when the ": 6394, + "miss": 6395, + "\\\":\\\"": 6396, + "set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account": 6397, + " bytes ": 6398, + "batch": 6399, + "====\\n * ": 6400, + "` (`": 6401, + "bool, ": 6402, + "recon": 6403, + ";\\n\\n // ": 6404, + "setApprovalForAll(address operator": 6405, + "delete": 6406, + "]\\n * ====\\n * ": 6407, + "\"lib/": 6408, + "-string": 6409, + "95": 6410, + "rSupply": 6411, + ");\\n\\n // ": 6412, + "This program is ": 6413, + "Pos": 6414, + "ome ": 6415, + "Revoked": 6416, + "owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this ": 6417, + "full ": 6418, + "result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n ": 6419, + "separ": 6420, + "`, and ": 6421, + "feeTo": 6422, + "filtered ": 6423, + "issues ": 6424, + ", v, r, s": 6425, + "IV": 6426, + "address(this)": 6427, + "first": 6428, + "Change": 6429, + ") return (false, 0": 6430, + "=lib/": 6431, + "ther ": 6432, + "allowed ": 6433, + "Note: ": 6434, + "minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s ": 6435, + "when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * ": 6436, + "``from``'s ": 6437, + "atch ": 6438, + "TokenIndex": 6439, + "from `": 6440, + "Approve": 6441, + "removed ": 6442, + "the owner ": 6443, + "2,\\n 2,\\n ": 6444, + "any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * ": 6445, + "domain separator": 6446, + "blob": 6447, + "compl": 6448, + "`account`.\\n */\\n function ": 6449, + "approved operator": 6450, + "ght ": 6451, + "REGISTRY": 6452, + "196": 6453, + "Trac": 6454, + "Paused(": 6455, + "uint16 _": 6456, + "variabl": 6457, + ";\\n\\n // The bit ": 6458, + "_EXTRA": 6459, + "name = name_;\\n ": 6460, + "Send": 6461, + "`\\n * ": 6462, + "totalSupply ": 6463, + "implements the ": 6464, + "_tOwned": 6465, + "╬╬╬╬": 6466, + "able is Context ": 6467, + "Renoun": 6468, + "blob/": 6469, + ";\\n\\n uint256 private ": 6470, + " bit ": 6471, + "AdminRole": 6472, + ", 0x20": 6473, + "mload(add(": 6474, + "prevOwnershipPacked": 6475, + "meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (": 6476, + ".code.length": 6477, + "3\\\\x8": 6478, + "nor ": 6479, + "amount);\\n ": 6480, + "address that ": 6481, + "tokens have been ": 6482, + "Oracle": 6483, + "\\\\xe3\\\\x8": 6484, + "can be applied to ": 6485, + "Creat": 6486, + "pop": 6487, + ");\\n\\n ": 6488, + "using {": 6489, + "generic ": 6490, + "[EIP ": 6491, + "@openzeppelin/contracts-": 6492, + "cleared when the ": 6493, + "approval is cleared when the ": 6494, + "approval is cleared when the token is ": 6495, + "\\n assembly {\\n ": 6496, + "balancer-": 6497, + "desired ": 6498, + "DA": 6499, + "ser": 6500, + "\\n\\n // ": 6501, + "s from ": 6502, + "\\\");\\n ": 6503, + "checking ": 6504, + "(\\n bytes32 ": 6505, + ") external;\\n function ": 6506, + "`account`.\\n *\\n * ": 6507, + "revert(add(32, ": 6508, + "Array": 6509, + "\\n *\\n * _Available since v4.7._\\n */\\n function ": 6510, + "_EXTRA_DATA": 6511, + ",\\n ": 6512, + "non ": 6513, + "tokenBalance": 6514, + "nos": 6515, + "spender, uint256 value": 6516, + ");\\nerror ": 6517, + "bytes32[] memory ": 6518, + "added ": 6519, + "as part ": 6520, + "token ID to ": 6521, + "hex ": 6522, + "reentrancy ": 6523, + "name = name_;\\n _symbol = symbol_": 6524, + "Cumulative": 6525, + "}(\\\"": 6526, + "ital": 6527, + "balanceOf(address(this": 6528, + "timelock": 6529, + "Period": 6530, + "tokensForDev": 6531, + "enalty": 6532, + "Denominator": 6533, + "balancer-labs/": 6534, + "How": 6535, + "RIC": 6536, + "pending": 6537, + "\\n ": 6538, + "for any ": 6539, + "```\\n *\\n * ": 6540, + "By default": 6541, + "caller must ": 6542, + "arithmetic": 6543, + "on behalf of `owner": 6544, + "to learn more about ": 6545, + "plicit": 6546, + "\\n * @param _": 6547, + "es[role].": 6548, + "balancer-labs/v2-": 6549, + "to` cannot be the zero address": 6550, + "ict": 6551, + ",\\n bytes calldata data": 6552, + "move": 6553, + "swapExactETHFor": 6554, + "%%%%": 6555, + "\"Ownable: new owner is ": 6556, + ");\\n }\\n ": 6557, + ") internal virtual {\\n uint256 ": 6558, + "initialize": 6559, + "`owner` s ": 6560, + "/= 10": 6561, + "release": 6562, + "-or": 6563, + "Get ": 6564, + "_d": 6565, + "enables ": 6566, + "push": 6567, + "...": 6568, + ");\\n\\n // ": 6569, + "\"// SPDX-License-Identifier: MIT\\n\\n": 6570, + "pool ": 6571, + "cannot overflow.\\n */\\n function ": 6572, + "-or-": 6573, + "types ": 6574, + "that is if it ": 6575, + "msg.data;\\n }\\n}\\n\"": 6576, + "security/": 6577, + "updatedIndex": 6578, + "ERC721.ownerOf(tokenId": 6579, + "cas": 6580, + "(address addr": 6581, + "This is ": 6582, + "mulDiv": 6583, + "() external view returns (address": 6584, + "NOT_ENTERED": 6585, + ") external;\\n\\n /**\\n * @notice ": 6586, + "Blacklist": 6587, + "\"Ownable: new owner is the zero address\"": 6588, + "() public virtual ": 6589, + "limits": 6590, + "a - ": 6591, + ";\\n }\\n }\\n\\n /**\\n * @dev ": 6592, + "approveMax": 6593, + "0.5.": 6594, + "er to ": 6595, + "state ": 6596, + "aft": 6597, + "\"// SPDX-License-Identifier: G": 6598, + "restrict ": 6599, + "uint128 ": 6600, + "`approved": 6601, + "ay ": 6602, + "Of(tokenId": 6603, + " is only ": 6604, + "Project": 6605, + ".\\n * Returns 0 if given ": 6606, + "}\\n\\n emit Transfer": 6607, + "modifier\\n * ": 6608, + "ACH": 6609, + "spend ": 6610, + ") {\\n value /= ": 6611, + ";\\n }\\n if (value >= ": 6612, + ", of a positive value.\\n * Returns 0 if given ": 6613, + ", of a positive value.\\n * Returns 0 if given 0": 6614, + "tack": 6615, + "toward": 6616, + "arm": 6617, + "shl": 6618, + "{\\n _": 6619, + "paused ": 6620, + "Signed ": 6621, + "` is set ": 6622, + "Non-": 6623, + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@": 6624, + "avoid": 6625, + "call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string": 6626, + "Sales": 6627, + "/src/": 6628, + "Duration": 6629, + "or be an ": 6630, + "maxSupply": 6631, + "encodeWithSignature": 6632, + "following ": 6633, + "fici": 6634, + "Overflow not ": 6635, + "/**\\n * @notice ": 6636, + "1967": 6637, + "or be an approved operator": 6638, + "t(": 6639, + "ERC-": 6640, + ") {\\n // ": 6641, + "buyMarketingFee": 6642, + "tokensForMarketing": 6643, + " bits\\\");\\n return ": 6644, + "An ": 6645, + "Renounc": 6646, + "canSwap": 6647, + "allow ": 6648, + "_CO": 6649, + "ordering": 6650, + "Ethereum Signed ": 6651, + "votes": 6652, + ") = _": 6653, + "extra ": 6654, + "reduc": 6655, + " bit": 6656, + "_beforeTokenTransfers": 6657, + ".sol';\\n": 6658, + "liquidity ": 6659, + "#(": 6660, + "//\\n//": 6661, + "es:": 6662, + ".sol\\\";\\nimport {": 6663, + "modulo ": 6664, + ", it is ": 6665, + "_checkOnERC721Received": 6666, + "OPERATOR": 6667, + "along with ": 6668, + "-utils/": 6669, + "some ": 6670, + "ite": 6671, + "_owners[tokenId": 6672, + "Setter": 6673, + "liquidityTokens": 6674, + "].add(": 6675, + ";\\n }\\n\\n // ": 6676, + "granted `role`, emits a {Role": 6677, + "inv": 6678, + "return\\n ": 6679, + "ify": 6680, + "Math.": 6681, + "reverted": 6682, + "Update the ": 6683, + " := add(": 6684, + "2**(": 6685, + "(address owner, address operator": 6686, + "Dec": 6687, + "just": 6688, + "lease ": 6689, + "must use ": 6690, + "\\r\\n * ": 6691, + "Exceeds the ": 6692, + "`index` ": 6693, + "df": 6694, + "vx": 6695, + "tically ": 6696, + "// solhint-disable-next-line ": 6697, + "``role": 6698, + "prod0 ": 6699, + "_balances[to": 6700, + "safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId": 6701, + "_TOKEN": 6702, + "isFeeExempt": 6703, + "`owner` enables ": 6704, + "RRRR": 6705, + "clear": 6706, + "Impl": 6707, + "wad": 6708, + "{ERC165": 6709, + "e which ": 6710, + "ance. ": 6711, + "(uint256 _": 6712, + "] = amount": 6713, + ");\\n return ": 6714, + "isApprovedForAll(address owner, address operator": 6715, + "missing ": 6716, + "field": 6717, + "selected ": 6718, + "ECDSA: invalid ": 6719, + ";\\n // ": 6720, + "address[] memory ": 6721, + "ates": 6722, + "from a ": 6723, + "Burned": 6724, + "Reser": 6725, + "nonReentrant ": 6726, + "copy": 6727, + "launch": 6728, + ";\\n emit Approval(owner, ": 6729, + "37": 6730, + "TIP": 6731, + "to-": 6732, + "IERC20Permit": 6733, + "}\\n\\n // ": 6734, + " of the `": 6735, + "constructor ": 6736, + "two numbers": 6737, + "2**256": 6738, + "size := ": 6739, + " may have ": 6740, + "eth_sign": 6741, + "set. O(1).\\n *\\n * Returns true if the ": 6742, + "voting pow": 6743, + "tokens of at least": 6744, + "TIP: ": 6745, + "ris": 6746, + "value, recipient": 6747, + "balanceOf}.\\n */\\n function ": 6748, + "MaxTxAmount": 6749, + "BurnFee": 6750, + "(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted ": 6751, + "e is used ": 6752, + "send value, recipient": 6753, + "the caller must have allowance for ": 6754, + "avoid ": 6755, + "unable to send value, recipient": 6756, + "Contract module which ": 6757, + "unable to send value, recipient may have ": 6758, + "both": 6759, + "igr": 6760, + "raft": 6761, + "utu": 6762, + "on-": 6763, + "existing ": 6764, + "length(": 6765, + "WithPermit": 6766, + ";\\n uint256 private ": 6767, + "word": 6768, + "mstore(": 6769, + ",,,,,,,,": 6770, + "-}[`functionCall`],\\n * but performing a delegate ": 6771, + ");\\n\\n /**\\n * @dev Emitted when `owner` enables ": 6772, + "address private _owner": 6773, + "address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (": 6774, + "Info ": 6775, + "address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata": 6776, + ".get": 6777, + "ence ": 6778, + "ampl": 6779, + "feeNumerator": 6780, + "Statu": 6781, + "module is used ": 6782, + "through inherit": 6783, + "make available ": 6784, + "transfer(address recipient, uint256 amount": 6785, + "It will make available ": 6786, + "ance. It will make available ": 6787, + "module is used through inherit": 6788, + "module is used through inheritance. It will make available ": 6789, + "\\n mapping(uint256 => ": 6790, + "relat": 6791, + "enough ": 6792, + "ade": 6793, + "= (": 6794, + " of all ": 6795, + "on fail": 6796, + ", address p3) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(": 6797, + ", string memory p3) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(": 6798, + ")\\\", p0, p1, p2));\\n\\t}\\n\\n\\tfunction ": 6799, + "Auction": 6800, + ", bool p3) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(": 6801, + ")\\\", p0, p1, p2, p3));\\n\\t}\\n\\n\\tfunction log(address ": 6802, + "amount exceeds balance\\\");\\n unchecked {\\n ": 6803, + "rounding direction": 6804, + ")\\\", p0, p1, p2, p3));\\n\\t}\\n\\n\\tfunction log(bool ": 6805, + ")\\\", p0, p1, p2, p3));\\n\\t}\\n\\n\\tfunction log(string memory ": 6806, + "call.\\n *\\n * _Available since v3.4._\\n */\\n function ": 6807, + "removeLiquidityETH": 6808, + "internal function is equivalent to {": 6809, + "indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables ": 6810, + "-or-later": 6811, + "risk": 6812, + "-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function ": 6813, + "1] = ": 6814, + "38": 6815, + "_prevent": 6816, + "ed\\n * ": 6817, + ";\\n\\ninterface ": 6818, + "forum": 6819, + "Updates:": 6820, + "deployer ": 6821, + "word ": 6822, + "approved for ": 6823, + "_marketingFee": 6824, + "42": 6825, + "efficient": 6826, + "long": 6827, + "ERC20-": 6828, + "Provider": 6829, + "decreased allowance below zero\"": 6830, + "set, that is if it ": 6831, + "` is zero, `tokenId` will be ": 6832, + ")\\\", p0, p1, p2, p3));\\n\\t\\tignored;\\n\\t}\\n\\n\\tfunction log(": 6833, + "set. O(1).\\n *\\n * Returns true if the value was ": 6834, + "-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall": 6835, + ")\\r\\n ": 6836, + "\\n // ": 6837, + "bytes memory buffer = new ": 6838, + "Returns whether ": 6839, + "using the ": 6840, + "Ownable: caller is not the owner": 6841, + "string(buffer": 6842, + "_preventSwap": 6843, + "bytes memory buffer = new bytes(": 6844, + "was": 6845, + "}\\r\\n ": 6846, + "approve}.": 6847, + "in the set. O(1": 6848, + "deriv": 6849, + "Token Standard": 6850, + "||\\n ": 6851, + "token/ERC20/extensions/IERC20Metadata": 6852, + "MerkleProof": 6853, + "corresponding\\n * ": 6854, + "still ": 6855, + "inverse *= 2 - denominator * inverse; // inverse mod 2^": 6856, + " ? ": 6857, + "\"log(": 6858, + "[account": 6859, + "ERC20Burnable": 6860, + " = value": 6861, + ";\\n using ": 6862, + "utils/Address": 6863, + "sellDevFee": 6864, + "}.\\n * - ": 6865, + "remove(": 6866, + "][operator": 6867, + "Rounding.": 6868, + "s `amount` tokens from `account`, ": 6869, + ".\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the ": 6870, + "TransferToNon": 6871, + "Fungible ": 6872, + "circ": 6873, + "``role``'s ": 6874, + "=-": 6875, + "UM": 6876, + "_paused": 6877, + "InE": 6878, + "type ": 6879, + "Delet": 6880, + "transfer to non ": 6881, + "_finalBuyTax": 6882, + "divisor cannot be zero.\\n */\\n function ": 6883, + "caller must own": 6884, + "_LI": 6885, + "market": 6886, + "\\n }\\n ": 6887, + "expir": 6888, + "_FI": 6889, + "Sc": 6890, + "`isContract": 6891, + "hand": 6892, + "uint256 c = ": 6893, + "\\n * to ": 6894, + ".\\n */\\n function totalSupply() external view returns (uint256": 6895, + " != 0) {\\n ": 6896, + ", address indexed newOwner": 6897, + "sqrt(a": 6898, + "izedWeight": 6899, + ".sol';\\nimport '": 6900, + "Gas": 6901, + "PRO": 6902, + "Table": 6903, + "ile": 6904, + "ject ": 6905, + "This function ": 6906, + "Minted(": 6907, + "_AU": 6908, + ". This is the ": 6909, + "uint amountOut": 6910, + ";\\n }\\n\\n function set": 6911, + "need": 6912, + "_balances[account] = ": 6913, + "known ": 6914, + "Interface of the ERC20 ": 6915, + "0.7.0": 6916, + "Non-Fungible ": 6917, + "ake": 6918, + "isting": 6919, + ";\\n }\\n\\n ": 6920, + "contract recipient": 6921, + "manual": 6922, + " ": 6923, + "following the ": 6924, + "ERC721ReceiverImplementer": 6925, + "Preset": 6926, + "call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target": 6927, + "TransferToNonERC721ReceiverImplementer": 6928, + "b0": 6929, + "trig": 6930, + ");\\r\\n ": 6931, + "ending ": 6932, + "istor": 6933, + "ERC1155": 6934, + "right": 6935, + "Comp": 6936, + "\"SafeMath: addition": 6937, + "\"SafeMath: multiplication overflow": 6938, + ") internal returns (bytes memory) {\\n require(": 6939, + "from `from` to `to`": 6940, + "[0] = ": 6941, + " the token or be an approved operator": 6942, + "Rounding rounding": 6943, + "functionality ": 6944, + "ACHED": 6945, + "caller must own the token or be an approved operator": 6946, + "Bpt": 6947, + " == address(0)": 6948, + "must be greater than ": 6949, + "\\n /// @dev ": 6950, + "https://eips.ethereum.org/EIPS/eip-721": 6951, + "\"SafeMath: division by ": 6952, + "\"SafeMath: subtraction": 6953, + "utils/Context.sol\"": 6954, + "(to, tokenId": 6955, + "approve(address spender, uint256 amount) external returns (bool": 6956, + "\"SafeMath: addition overflow\"": 6957, + "\"SafeMath: multiplication overflow\"": 6958, + "pid": 6959, + "tSupply": 6960, + "as defined ": 6961, + "== address(0)": 6962, + ") external;\\n}\\n\"": 6963, + "transferOwnership(address newOwner": 6964, + "▓▓▓▓": 6965, + "spendAllowance": 6966, + "BPT": 6967, + "mint to the zero address\"": 6968, + "rounded toward": 6969, + "\"SafeMath: division by zero\"": 6970, + "'s balance ": 6971, + "blocks": 6972, + "more expensi": 6973, + "(address indexed previousOwner": 6974, + "IME": 6975, + "renounceOwnership() public virtual ": 6976, + "Multip": 6977, + ") {\\n _name = name_;\\n _symbol = symbol_": 6978, + "ERC721Receiver implementer": 6979, + "transfer to non ERC721Receiver implementer": 6980, + "Random": 6981, + ".start": 6982, + "hashed": 6983, + "\\n * @param ": 6984, + "++;\\n ": 6985, + "lateral ": 6986, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8": 6987, + ") internal virtual {}\\n\\n /**\\n * @dev ": 6988, + "custom message ": 6989, + "Rounding.Up": 6990, + ", bytes memory ": 6991, + "\\\", ": 6992, + "consi": 6993, + "chainid": 6994, + "separat": 6995, + "selected rounding direction": 6996, + "following the selected rounding direction": 6997, + "(address indexed previousOwner, address indexed newOwner": 6998, + "tun": 6999, + "\\n * @dev ": 7000, + "ased": 7001, + "begin": 7002, + "totalSupply() public view virtual override returns (": 7003, + "\\r\\n event ": 7004, + "STA": 7005, + "Subtr": 7006, + "decreased allowance below zero": 7007, + "Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (": 7008, + "provides a ": 7009, + "address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return ": 7010, + "Ou": 7011, + "hase": 7012, + "\\n ) internal pure returns (": 7013, + "s is ": 7014, + ", newOwner": 7015, + "(address sender": 7016, + "totalHash": 7017, + "value failed": 7018, + "be\\n * ": 7019, + "with value failed": 7020, + "mulmod": 7021, + "call with value failed": 7022, + "ER_REGISTRY": 7023, + "LTER_REGISTRY": 7024, + "Internal function ": 7025, + "balance for call": 7026, + "VRF": 7027, + "bearer": 7028, + "OPERATOR_FI": 7029, + "_preventSwapBefore": 7030, + "OPERATOR_FILTER_REGISTRY": 7031, + "Event": 7032, + "pass": 7033, + "address) {\\n ": 7034, + "getRoleAdmin": 7035, + "s the contract": 7036, + ") internal pure returns (uint256) {\\n unchecked {\\n ": 7037, + "(uint256 a, uint256 b) internal pure returns (bool, ": 7038, + "_finalSellTax": 7039, + "Non-Fungible Token Standard": 7040, + "s this ": 7041, + "Add ": 7042, + "with\\n * `": 7043, + "minimum": 7044, + "Ownable is Context ": 7045, + "TotalFee": 7046, + "/EIPs/": 7047, + "777": 7048, + "https://github.com/ethereum/EIPs/": 7049, + "clusive ": 7050, + "\"SafeMath: subtraction overflow\"": 7051, + "31": 7052, + "ties ": 7053, + ") |": 7054, + "a function call": 7055, + "devWallet": 7056, + "in construction": 7057, + ";\\n require(": 7058, + "== Rounding.Up": 7059, + "swapBack": 7060, + "OwnershipTransferred(address indexed previousOwner, address indexed newOwner": 7061, + "rounding == Rounding.Up": 7062, + ");\\n }\\n }\\n\\n function ": 7063, + "relation": 7064, + "rounding == Rounding.Up && ": 7065, + "% b": 7066, + ", since ": 7067, + "unrealis": 7068, + "`.\\n // - `": 7069, + ";\\n\\nimport \\\"../": 7070, + "means": 7071, + "called by any ": 7072, + "approvedAddressSlot": 7073, + "/*//////////////////////////////////////////////////////////////": 7074, + ",\\r\\n address to": 7075, + "(address from, address to, uint256 amount": 7076, + ";\\n\\n // Mapping from token ID to ": 7077, + "_msgSender(), \\\"Ownable: caller is not the owner": 7078, + "Updates:\\n // - `": 7079, + "Bool": 7080, + "`approve": 7081, + "explicit": 7082, + ",\\n // ": 7083, + "for {": 7084, + "can then ": 7085, + "`from` ": 7086, + ");\\n\\n /**\\n * @dev Emitted when the ": 7087, + "struct the ": 7088, + "specification": 7089, + "Metadata is ": 7090, + "config.": 7091, + "() public view virtual override returns (string memory) {\\n return _symbol": 7092, + "() public view virtual override returns (string memory) {\\n return _name": 7093, + "string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_": 7094, + "relationship": 7095, + ")\\n ": 7096, + "AM": 7097, + "[IMPORTANT": 7098, + "int24": 7099, + ". On": 7100, + "poch": 7101, + "paus": 7102, + "_setAutomatedMarketMakerPair": 7103, + "by\\n * `": 7104, + "maximum `": 7105, + "html#": 7106, + "log2(a": 7107, + "_owner = newOwner": 7108, + "Throws if called by any ": 7109, + " |": 7110, + "a % b": 7111, + "contracts": 7112, + "MessageHash": 7113, + ") private pure returns (": 7114, + "msg.value": 7115, + "number of tokens that ": 7116, + "access control ": 7117, + "counter._": 7118, + "(string ": 7119, + ",address ": 7120, + "44": 7121, + "Perform": 7122, + "acon": 7123, + "ERC20Preset": 7124, + "light": 7125, + " is IERC165 {\\n /**\\n * @dev ": 7126, + "comment": 7127, + "\"ERC20: decreased allowance below zero\"": 7128, + "Part": 7129, + ".sol\\\";\\n\\ncontract ": 7130, + ")\\n external\\n ": 7131, + "purch": 7132, + "//////////////////////////////////////////////////////////////*/": 7133, + "Equivalent to ": 7134, + "decl": 7135, + "owner to ": 7136, + "where": 7137, + "Insufficient": 7138, + "ayer": 7139, + "proofFlag": 7140, + "available to ": 7141, + "assume that ": 7142, + "from the caller's\\n * ": 7143, + "https://github.com/ethereum/EIPs/issues/": 7144, + "eil": 7145, + " for uint256": 7146, + "expTable": 7147, + "edia": 7148, + "startTokenId, ": 7149, + "owner nor ": 7150, + "whenever ": 7151, + "uint160(": 7152, + "tryRecover(hash": 7153, + "from the caller's\\n * allowance": 7154, + "EO": 7155, + "Sto": 7156, + "`\\n // - ": 7157, + "cy ": 7158, + "amountToSwap": 7159, + "20#": 7160, + "729": 7161, + "conver": 7162, + "nextTokenId ": 7163, + "ating the ": 7164, + "onERC721Received.selector": 7165, + "amountBMin": 7166, + "amountAMin": 7167, + ".\\n */\\ninterface IERC20": 7168, + "setting the ": 7169, + "normalizedWeight": 7170, + "HEX_SYMBOLS": 7171, + "Reflection": 7172, + "`\\n // - [": 7173, + "ath": 7174, + "s `role": 7175, + "owner. ": 7176, + ".\\n */\\n function get": 7177, + "upgrad": 7178, + "0x0": 7179, + "returns (bool) {\\n return _": 7180, + "` is allowed to ": 7181, + "MarketingWallet": 7182, + "|| super.supportsInterface(interfaceId": 7183, + "erc721": 7184, + "(account, address(0), amount": 7185, + "new owner is the zero address": 7186, + "impossible ": 7187, + "guarante": 7188, + "transferOwnership(address newOwner) public virtual ": 7189, + "borrow": 7190, + "mu": 7191, + "s an ": 7192, + "provide ": 7193, + "bytes32 _": 7194, + "> 0) {\\n ": 7195, + "voting": 7196, + "version of ": 7197, + "packedOwnerships[": 7198, + "instead ": 7199, + "upgradeable": 7200, + "When `from` and `to` are both non-zero, ": 7201, + "extra": 7202, + ". S": 7203, + "`amount` is ": 7204, + "Ownable: new owner is the zero address": 7205, + "ability ": 7206, + "division by zero": 7207, + "basic ": 7208, + "except ": 7209, + "SignedMessageHash": 7210, + "Clear ": 7211, + "reconstruct the ": 7212, + "S_": 7213, + "_baseURI": 7214, + "limit ": 7215, + "nft ": 7216, + "interes": 7217, + "\\n * a ": 7218, + "acce": 7219, + ";\\n while (": 7220, + "tak": 7221, + "LENG": 7222, + "non-zero ": 7223, + "uint amountIn": 7224, + "account other than ": 7225, + "there is ": 7226, + "Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return ": 7227, + "[IMPORTANT]\\n * ====\\n * ": 7228, + "Dis": 7229, + "UB": 7230, + "based ": 7231, + "t/": 7232, + "x_": 7233, + "enfor": 7234, + ", msg.sender": 7235, + "\\n * `amount": 7236, + "fromBalance ": 7237, + "{\\n using ": 7238, + "thereby ": 7239, + "poolId": 7240, + " bits\\n *\\n * _Available since v4.7._\\n */\\n function ": 7241, + "address) {\\n return _owner": 7242, + "} else {\\n return ": 7243, + "MaxTxAmountUpdated": 7244, + "Throws if called by any account other than ": 7245, + "(uint ": 7246, + "en\\n * ": 7247, + "(uint256 index": 7248, + ")\\n internal": 7249, + "Changed(": 7250, + "00000000000000000000000000000000": 7251, + "revert reason is ": 7252, + "you can ": 7253, + ".\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function ": 7254, + "(\\n address target,\\n bytes memory data,\\n uint256 value": 7255, + "_packedOwnerships[": 7256, + "(data);\\n return verifyCallResult(success, returndata, errorMessage": 7257, + "Safely transfers `tokenId` token from `from` to `to": 7258, + "_index": 7259, + "_packedAddressData": 7260, + "s on ": 7261, + "fund ": 7262, + "= false": 7263, + "aff": 7264, + "lower than ": 7265, + "] = to": 7266, + "EthSignedMessageHash": 7267, + "defined by\\n * `": 7268, + "someone ": 7269, + "Additionally, ": 7270, + "bitr": 7271, + "Decimals": 7272, + "derived ": 7273, + "LENGTH": 7274, + "ps": 7275, + "por": 7276, + "des": 7277, + "returndatasize": 7278, + "is\\n * ": 7279, + "\\r\\n // ": 7280, + "vali": 7281, + "ries": 7282, + " = _owner": 7283, + "in a ": 7284, + "leave the ": 7285, + "_balances[sender": 7286, + "then deduc": 7287, + "shr(": 7288, + "roller": 7289, + "\\n virtual\\n override": 7290, + "both the ": 7291, + ":\\n *\\n * ": 7292, + "CO": 7293, + "My": 7294, + "_update": 7295, + "\\\");\\n ": 7296, + "from one ": 7297, + "\"ERC20: burn ": 7298, + "_tokenApprovals": 7299, + "issuecomment": 7300, + "break": 7301, + "govern": 7302, + "s from the ": 7303, + "toEthSignedMessageHash": 7304, + "uint[] memory ": 7305, + ",\\n uint256[] memory ": 7306, + "for `owner": 7307, + ") {\\n return interfaceId == type(": 7308, + "forever": 7309, + ".\\n */\\n function _mint": 7310, + "utils/Strings": 7311, + "returndata.length": 7312, + ".\\n *\\n * _Available since v3.4._\\n */\\n function ": 7313, + "\"ERC20: transfer amount exceeds balance\"": 7314, + "tokens of at least\\n * `amount": 7315, + "58": 7316, + "`: ": 7317, + "`onlyOwner": 7318, + "match": 7319, + "256 ": 7320, + ".\\n *\\n * @param ": 7321, + ".sol\\\";\\n\\n/**\\n * @title ": 7322, + "SwapThreshold": 7323, + "| |": 7324, + "When `to": 7325, + "address of the current owner": 7326, + "ownership.addr": 7327, + "(int256 value": 7328, + ".\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value": 7329, + "`amount` is then deduc": 7330, + "Throws if called by any account other than the owner": 7331, + ".\\n *\\n * _Available since v3.4._\\n */\\n function try": 7332, + "tokens of at least\\n * `amount`.\\n */\\n function ": 7333, + "Fixed": 7334, + ". See the ": 7335, + "lower": 7336, + "0.4.": 7337, + ", address _": 7338, + ").length": 7339, + "`.\\n _": 7340, + "only available to ": 7341, + "3524": 7342, + "::::::::": 7343, + "transferred to `to`.\\n * - When `from": 7344, + ". The result is rounded toward": 7345, + "Helper": 7346, + "%\"": 7347, + "CAU": 7348, + "ITH": 7349, + ", or ": 7350, + "exclusive ": 7351, + "ing ownership ": 7352, + "airdrop": 7353, + "bytes32 public constant ": 7354, + " betwe": 7355, + "allowance to ": 7356, + ");\\n return (": 7357, + "mary": 7358, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7": 7359, + "as the initial ": 7360, + "HASHED": 7361, + " of two unsigned integers, reverting ": 7362, + "transfer(address to, uint256 amount": 7363, + "}\\n * ```\\n *\\n * ": 7364, + "-263524": 7365, + "https://github.com/ethereum/EIPs/issues/20#": 7366, + "owner. It will ": 7367, + "issuecomment-263524": 7368, + "CAUTION": 7369, + "https://github.com/ethereum/EIPs/issues/20#issuecomment-263524": 7370, + "https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729": 7371, + "\"Exceeds the ": 7372, + ".\\n * ": 7373, + "balances ": 7374, + "---": 7375, + "sync": 7376, + "will leave the ": 7377, + "fortun": 7378, + "{\\n address private _owner": 7379, + "received ": 7380, + "any functionality ": 7381, + "that is only available to ": 7382, + "mechanism. ": 7383, + "obbl": 7384, + "duration": 7385, + "ethForLiquidity": 7386, + " == 0) {\\n ": 7387, + "(to).": 7388, + "contract without an owner": 7389, + ")) private _allowances": 7390, + "By default, ": 7391, + "Renouncing ownership ": 7392, + "Clear approval": 7393, + "will leave the contract without an owner": 7394, + "any functionality that is only available to ": 7395, + "Renouncing ownership will leave the contract without an owner": 7396, + "Fallback": 7397, + "WITH": 7398, + "\\n * of ": 7399, + "transferring ": 7400, + ") internal {\\n require(": 7401, + "MIT ": 7402, + ";\\n }\\n\\n /**\\n * @dev See {IERC721Metadata": 7403, + "Initializable": 7404, + "access restriction": 7405, + "call failed\"": 7406, + "flag.\\n *\\n * _Available since v3.4._\\n */\\n function try": 7407, + "Initializes the contract setting the ": 7408, + "Creates ": 7409, + "Bit": 7410, + "Store": 7411, + "Invalid ": 7412, + "string(abi.encode": 7413, + ") public view override returns (": 7414, + " is to ": 7415, + "not be possible to ": 7416, + ",\\n address _": 7417, + "(from, to, amount);\\n\\n ": 7418, + "them to ": 7419, + ",\\n uint256 ": 7420, + "contract without owner. It will ": 7421, + "Leaves the ": 7422, + "forum.": 7423, + "deployer as the initial ": 7424, + "any functionality that is only available to the owner": 7425, + "not be possible to call": 7426, + "contract without owner. It will not be possible to call": 7427, + "Leaves the contract without owner. It will not be possible to call": 7428, + "0e": 7429, + "512": 7430, + "s on the ": 7431, + "unfortun": 7432, + "allPair": 7433, + "function call ": 7434, + "ExcludeFrom": 7435, + "\\r\\n // ": 7436, + "SafeERC20: ": 7437, + "allowance by ": 7438, + "Payee": 7439, + "ource ": 7440, + "afterward": 7441, + "2612": 7442, + "without access restriction": 7443, + "_CACHED": 7444, + "there is an ": 7445, + "& _BITMASK": 7446, + "underflow": 7447, + "Internal function without access restriction": 7448, + " or": 7449, + "\"Cannot ": 7450, + "OF": 7451, + "draft": 7452, + "}. This ": 7453, + "seaDrop": 7454, + "owner() public view virtual returns (": 7455, + "data` ": 7456, + "swapThreshold": 7457, + "newOwner != address(0), \\\"": 7458, + "RoleMember": 7459, + "TaxSwap": 7460, + "transfer to the zero address\\\");\\n\\n _beforeTokenTransfer": 7461, + "protocol ": 7462, + "0.5.0": 7463, + "secuti": 7464, + "ategy": 7465, + "renounceOwnership() public virtual onlyOwner {\\n ": 7466, + "Initializes the contract setting the deployer as the initial ": 7467, + ".add(": 7468, + "It": 7469, + "_lock": 7470, + "b3": 7471, + "here": 7472, + "\\n //////////////////////////////////////////////////////////////*/": 7473, + "addresses ": 7474, + "ing\\n * ": 7475, + "/**\\n * @dev ": 7476, + ". If ": 7477, + "onlyRole(": 7478, + ");\\n\\n /// @notice ": 7479, + "log256": 7480, + "log10": 7481, + ") {\\n revert ": 7482, + ". This function ": 7483, + ", and the ": 7484, + ".\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `": 7485, + "minted for `to`.\\n * - When `to": 7486, + "[](": 7487, + "optional metadata ": 7488, + "_balances[to] += ": 7489, + "Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\"": 7490, + "{decimals} ": 7491, + "bytes16": 7492, + "rowth": 7493, + "indow": 7494, + ") revert Mint": 7495, + "mechanism, ": 7496, + ";\\r\\n }\\r\\n\\r\\n /**\\r\\n * @dev ": 7497, + "` to `recipient": 7498, + "Hook that is called after ": 7499, + "tokens are moved ": 7500, + ");\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, ": 7501, + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function ": 7502, + "ERC20PresetMinter": 7503, + "Initializes the contract setting the deployer as the initial owner": 7504, + " += ": 7505, + "+ _": 7506, + ",\\n ": 7507, + "Gi": 7508, + "OW": 7509, + "xs": 7510, + "══": 7511, + "one that ": 7512, + "miner": 7513, + "upd": 7514, + "ers. ": 7515, + ")\\n external\\n view\\n returns (": 7516, + "value of 18": 7517, + "_allowances[owner][spender] = amount": 7518, + "`sender` to `recipient": 7519, + "protect ": 7520, + "newOwner != address(0), \\\"Ownable: new owner is the zero address": 7521, + "-1": 7522, + "/[": 7523, + "EL": 7524, + "Und": 7525, + "_previous": 7526, + "}\\r\\n }\\r\\n": 7527, + "Initial": 7528, + "params.": 7529, + "`from`) ": 7530, + "deploys the contract": 7531, + "\\u003e": 7532, + "execution": 7533, + "NFT ": 7534, + "and the new ": 7535, + "transaction ordering": 7536, + ").interfaceId || super.supportsInterface(interfaceId": 7537, + "provided ": 7538, + "registered ": 7539, + "bring": 7540, + "owner() == ": 7541, + "(`to": 7542, + "Bew": 7543, + "don": 7544, + ", bool _": 7545, + "ERO": 7546, + "spender` cannot be the zero address.\\n * - `": 7547, + " to mitig": 7548, + "plat": 7549, + "decimals_": 7550, + "hashed ": 7551, + "allowance mechanism. ": 7552, + "lastTokenIndex": 7553, + "integer ": 7554, + "solution": 7555, + "account (`from`) ": 7556, + "another (`to": 7557, + "setFeeTo": 7558, + "limitsInE": 7559, + ". One ": 7560, + "from one account (`from`) ": 7561, + "uint[] memory amounts": 7562, + "ble": 7563, + "s the risk": 7564, + "value afterward": 7565, + "that changing ": 7566, + "that someone ": 7567, + "with this method ": 7568, + "are that changing ": 7569, + "ate this ": 7570, + "new allowance": 7571, + "use both the ": 7572, + "`value` is the ": 7573, + "first reduce the ": 7574, + "condition is to ": 7575, + "places ": 7576, + "possible solution": 7577, + "allowed to spend ": 7578, + "votes ": 7579, + "_reduceBuyTax": 7580, + "getAmounts": 7581, + "taken to ": 7582, + "destroy": 7583, + "_STAR": 7584, + "an allowance with this method ": 7585, + "transaction ordering. One ": 7586, + "brings the risk": 7587, + "Beware that changing ": 7588, + "first reduce the spender": 7589, + "condition is to first reduce the spender": 7590, + "an allowance with this method brings the risk": 7591, + "transaction ordering. One possible solution": 7592, + "Beware that changing an allowance with this method brings the risk": 7593, + "Ke": 7594, + "ely": 7595, + "tokenId);\\n\\n ": 7596, + ") public payable ": 7597, + "uint8) {\\n return ": 7598, + "allowance of a ": 7599, + "remainder": 7600, + "`owner` is set ": 7601, + "`spender` for an ": 7602, + "Note that `value` ": 7603, + "`value` tokens are moved ": 7604, + "If the next ": 7605, + ");\\n }\\n\\n ": 7606, + "Comput": 7607, + " != address(0), \\\"ERC20: approve to ": 7608, + "may be zero": 7609, + "0 and set ": 7610, + "on failure": 7611, + "`amount` is then deducted ": 7612, + "allowance to 0 and set ": 7613, + "allowance by unfortun": 7614, + "and the new allowance by unfortun": 7615, + "`value` is the new allowance": 7616, + "_reduceBuyTaxAt": 7617, + "allowance of a `spender` for an ": 7618, + "`owner` is set by": 7619, + "Note that `value` may be zero": 7620, + "`value` tokens are moved from one account (`from`) ": 7621, + "allowance of a `spender` for an `owner` is set by": 7622, + "Hand": 7623, + "ZERO": 7624, + "ceil": 7625, + "sk": 7626, + ") that can be ": 7627, + "/**\\n * Returns the ": 7628, + "abc": 7629, + "zero by default": 7630, + "the\\n // ": 7631, + "import \\\"@openzeppelin/contracts/": 7632, + "\"ERC20: mint to the zero address\"": 7633, + "tection": 7634, + "may use both the ": 7635, + ";\\n }\\n uint256 ": 7636, + "string,string,": 7637, + "{approve}. ": 7638, + "call to {approve}. ": 7639, + "account (an owner": 7640, + "remaining number of tokens that ": 7641, + "granted exclusive ": 7642, + "unicode": 7643, + "specific function": 7644, + "desired value afterward": 7645, + "beginn": 7646, + "Ownable is Context {\\n address private _owner": 7647, + "access control mechanism, ": 7648, + "there is an account (an owner": 7649, + "allowance mechanism. `amount` is then deducted ": 7650, + "that someone may use both the ": 7651, + "transaction ordering. One possible solution to mitig": 7652, + ") that can be granted exclusive ": 7653, + "call to {approve}. `value` is the new allowance": 7654, + "access control mechanism, where": 7655, + "there is an account (an owner) that can be granted exclusive ": 7656, + "there is an account (an owner) that can be granted exclusive access ": 7657, + "();\\n error ": 7658, + "MU": 7659, + "t\\n * ": 7660, + "` through ": 7661, + "for more ": 7662, + "value changes ": 7663, + "are called": 7664, + "times": 7665, + "action ": 7666, + "buyDevFee": 7667, + "_mintAmount": 7668, + ";\\r\\n\\r\\n ": 7669, + "receiver, ": 7670, + "temp ": 7671, + "on behalf of `owner` through ": 7672, + "remaining number of tokens that `spender` ": 7673, + "desired value afterwards:": 7674, + "value changes when ": 7675, + "CT": 7676, + "a0": 7677, + "der of ": 7678, + "spender != address(0), \\\"ERC20: approve to ": 7679, + "} are called": 7680, + "totalFee": 7681, + ");\\n\\n uint256 ": 7682, + ").\\n *\\n * ": 7683, + "ids are ": 7684, + "transferFrom} are called": 7685, + "remainder of ": 7686, + "bool,bool,": 7687, + "assembly {\\n // ": 7688, + "less than 3": 7689, + "compli": 7690, + "{transferFrom}. This ": 7691, + "old and the new allowance by unfortun": 7692, + "original ": 7693, + "Sets `amount` as the allowance of `spender` over ": 7694, + "means\\n * ": 7695, + "ate this rac": 7696, + "HA": 7697, + "_stake": 7698, + "`. This ": 7699, + "n ": 7700, + "rate": 7701, + "unless ": 7702, + "sequ": 7703, + "be changed ": 7704, + "Balances": 7705, + "address(0x": 7706, + "can later ": 7707, + "ethAmount": 7708, + "_isApprovedOrOwner": 7709, + "interfaceId`. ": 7710, + ".org/": 7711, + "additional": 7712, + "operations": 7713, + "staker": 7714, + "infinite ": 7715, + "allowed to spend on behalf of `owner` through ": 7716, + ", ''": 7717, + "uint256).max": 7718, + ". To ": 7719, + "domain": 7720, + "type(uint256).max": 7721, + "Claimed": 7722, + "{approve} or {transferFrom} are called": 7723, + "_BURNED": 7724, + "checkpoints": 7725, + "(address spender, uint256 addedValue": 7726, + "10 ** 2": 7727, + "identified": 7728, + "necessari": 7729, + "Tracker": 7730, + "Contract module which provides a ": 7731, + "(address sender, address ": 7732, + "basic access control mechanism, where": 7733, + "that someone may use both the old and the new allowance by unfortun": 7734, + "transaction ordering. One possible solution to mitigate this rac": 7735, + "value changes when {approve} or {transferFrom} are called": 7736, + "allowed to spend on behalf of `owner` through {transferFrom}. This ": 7737, + "Contract module which provides a basic access control mechanism, where": 7738, + "that someone may use both the old and the new allowance by unfortunate": 7739, + "Not ": 7740, + ", _msgSender()": 7741, + "can't ": 7742, + "presale": 7743, + ";\\n\\n // Token ": 7744, + "OOOOOOOO": 7745, + "with {transferOwnership": 7746, + "token by either {approve} or {setApprovalForAll}.\\n * - ": 7747, + "CumulativeLast": 7748, + "MIT licen": 7749, + "be changed with {transferOwnership": 7750, + "7d": 7751, + "Softwa": 7752, + "those ": 7753, + ", etc": 7754, + "FromTarget": 7755, + "added to the ": 7756, + "sender,\\n address ": 7757, + "IERC20 ": 7758, + "structu": 7759, + ").div(": 7760, + "` is an ": 7761, + ".\\n unchecked {\\n ": 7762, + "account will be the ": 7763, + "Posi": 7764, + "\\n *\\n * Emits an {Approval": 7765, + "assets ": 7766, + "RecoverError ": 7767, + "their use ": 7768, + "your functions to ": 7769, + "Counter storage ": 7770, + "entire ": 7771, + "math/Math": 7772, + "`, which can be applied to ": 7773, + "the owner account will be the ": 7774, + "restrict their use ": 7775, + "module is used through inheritance. It will make available the ": 7776, + "`onlyOwner`, which can be applied to ": 7777, + "(int256 value) internal pure returns (": 7778, + "By default, the owner account will be the ": 7779, + "seaDropImpl": 7780, + "one that deploys the contract": 7781, + "can later be changed with {transferOwnership": 7782, + "your functions to restrict their use ": 7783, + "`onlyOwner`, which can be applied to your functions to restrict their use ": 7784, + "By default, the owner account will be the one that deploys the contract": 7785, + "By default, the owner account will be the one that deploys the contract. Th": 7786, + "merkle ": 7787, + "requi": 7788, + "refund ": 7789, + "uint256-}[`": 7790, + "` functions ": 7791, + "\\n // the ": 7792, + "removed": 7793, + "Updated(": 7794, + "\\n /// @param _": 7795, + "\"@openzeppelin/contracts/utils/Context.sol\"": 7796, + "`], ": 7797, + "flash": 7798, + "We can ": 7799, + "_redis": 7800, + "every ": 7801, + "increaseAllowance(address spender, uint256 addedValue": 7802, + "oraclize": 7803, + "keep ": 7804, + "=-=-": 7805, + "ERC20PresetMinterPauser": 7806, + "Det": 7807, + "cons": 7808, + "lities": 7809, + "_maxTaxSwap": 7810, + "reserve0": 7811, + "temp = value": 7812, + "`tokenId` token is ": 7813, + "the caller's account": 7814, + "_operatorApprovals": 7815, + "mload(add(signature": 7816, + "owner() == _msgSender(), \\\"Ownable: caller is not the owner": 7817, + " a ": 7818, + "-in": 7819, + "JS": 7820, + "owner != address(0), \\\"ERC20: approve ": 7821, + "ific": 7822, + ") external onlyOwner ": 7823, + "(uint256 amount": 7824, + "transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ": 7825, + "interface defined by\\n * `": 7826, + ", and it ": 7827, + ",\\n * thereby ": 7828, + "ECDSA-": 7829, + "obta": 7830, + "assembly {\\n ": 7831, + "assembly {\\n ": 7832, + "(token, ": 7833, + "(address target, bytes memory data) internal returns (bytes memory) {\\n return ": 7834, + "Holder": 7835, + "(address spender, uint256 subtractedValue": 7836, + "`account` had": 7837, + "Ethereum Signed Message": 7838, + "(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n ": 7839, + "Renouncing ownership will leave the contract without an owner,\\n * thereby ": 7840, + "interface defined by\\n * `interfaceId`. ": 7841, + "09": 7842, + "](": 7843, + "dered ": 7844, + "ToCopy": 7845, + ");\\n}\\n\\n": 7846, + "created ": 7847, + "Minted ": 7848, + "using a ": 7849, + "}.\\n */\\n function totalSupply() public view virtual override returns (": 7850, + "possible: ": 7851, + "representing the ": 7852, + "Overload": 7853, + "at the end": 7854, + ") external;\\n\\n function ": 7855, + "_initialBuyTax": 7856, + "Granted": 7857, + "uint8 v,\\n bytes32 r,\\n bytes32 ": 7858, + "above": 7859, + "update the allowance ": 7860, + "Overflow not possible: ": 7861, + "address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev ": 7862, + "can later be changed with {transferOwnership}.": 7863, + ").\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function ": 7864, + "} on ": 7865, + "lied ": 7866, + "\\n *": 7867, + ";\\n\\nimport \\\"@openzeppelin/contracts/": 7868, + "\\n * `onlyOwner": 7869, + "AccessControl: ": 7870, + " > 0) {\\n ": 7871, + "vesting": 7872, + "gas.\\n */\\n function ": 7873, + "token/ERC721/IERC721": 7874, + ";\\n }\\n\\n function ": 7875, + "this contract implements the ": 7876, + "Returns true if this contract implements the ": 7877, + "Can only be called by the current owner.\\n */\\n function ": 7878, + "burn from the zero address\"": 7879, + "invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function ": 7880, + "Throws if called by any account other than the owner.\\n */\\n modifier ": 7881, + "any functionality that is only available to the owner.\\n */\\n function ": 7882, + "Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner": 7883, + "#how-": 7884, + "-are": 7885, + "-identified": 7886, + "ield": 7887, + "ton": 7888, + "tition": 7889, + "\\n * ": 7890, + "The address of the ": 7891, + "transfer from the zero address\\\");\\n require(": 7892, + "safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ": 7893, + "ing\\n * the ": 7894, + "these ids are ": 7895, + "requen": 7896, + "(bool success, ) = ": 7897, + "decreaseAllowance(address spender, uint256 subtractedValue": 7898, + "standard as defined ": 7899, + "interfaces-are": 7900, + "how these ids are ": 7901, + "Can only be called by the current owner.\\n *\\n * NOTE: ": 7902, + "https://eips.ethereum.org/EIPS/eip-165#how-": 7903, + "-name-": 7904, + "[EIP section": 7905, + "must use less than 3": 7906, + "EOA": 7907, + "Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner(": 7908, + "standard as defined in the EIP": 7909, + "interfaces-are-identified": 7910, + "how these ids are created": 7911, + "Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby ": 7912, + "https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified": 7913, + "(e.g. ": 7914, + ".\\n /// @param ": 7915, + "CR": 7916, + "ba": 7917, + "futu": 7918, + "lash": 7919, + "s any ": 7920, + "enable": 7921, + "deposi": 7922, + ",\\n uint8 v,\\n bytes32 r,\\n bytes32 ": 7923, + "indexes[": 7924, + " * (": 7925, + "period": 7926, + ",\\n uint256 tokenId": 7927, + "numberOf": 7928, + "();\\n if (": 7929, + ");\\n\\n // Clear approval": 7930, + "immutable _": 7931, + "Remove": 7932, + "fixed length": 7933, + "Moves `amount` tokens from the caller's account": 7934, + "above ": 7935, + "After": 7936, + "merkleRoot": 7937, + "want to ": 7938, + "to learn more about how these ids are created": 7939, + "transferOwnership(address newOwner) public virtual onlyOwner {\\n require(": 7940, + "step": 7941, + "lies ": 7942, + "temp != 0) {\\n ": 7943, + "_NEXT_INITIALIZED": 7944, + "OUNT": 7945, + "dividing two unsigned integ": 7946, + "iszero(": 7947, + "_AUX": 7948, + ";\\n while (temp != 0) {\\n ": 7949, + "address of the current owner.\\n */\\n function ": 7950, + "remainder of dividing two unsigned integ": 7951, + "(string memory ": 7952, + "O(1": 7953, + "];\\n }\\n\\n /**\\n * @dev See {IERC721-": 7954, + "js": 7955, + "\\n * there is an account (an owner) that can be granted exclusive access ": 7956, + "s the `": 7957, + "ote": 7958, + "Allowance(": 7959, + ";\\n address public ": 7960, + "If `account` had": 7961, + "Auto": 7962, + "}\\r\\n\\r\\n": 7963, + "_initialSellTax": 7964, + "to\\n * specific function": 7965, + "days": 7966, + "_approve(owner, spender, currentAllowance ": 7967, + ";\\n\\n // The bit position": 7968, + "\"// SPDX-License-Identifier: GPL-3.0": 7969, + "JSON": 7970, + "any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n ": 7971, + "\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific function": 7972, + "Spl": 7973, + "`.\\n *\\n * Requirements:\\n *\\n * - ": 7974, + "ik": 7975, + "ward ": 7976, + "itter": 7977, + "fromBalance": 7978, + "development": 7979, + "confl": 7980, + "bytes32) {\\n return ": 7981, + "burned ": 7982, + "signific": 7983, + ";\\n\\n /// @notice ": 7984, + "0x00": 7985, + "bool success": 7986, + ");\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner": 7987, + "ID of the token": 7988, + "ed in a ": 7989, + "_TIME": 7990, + "_getRate": 7991, + "ecause the ": 7992, + "DomainSeparator": 7993, + "bptAmount": 7994, + ";\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner": 7995, + "Library": 7996, + "\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * ": 7997, + "_sell": 7998, + "awa": 7999, + "reveal": 8000, + "\\\";\\n }\\n uint256 ": 8001, + "000 ": 8002, + " ": 8003, + "s.html#": 8004, + "and/": 8005, + "note ": 8006, + "(uint256 a, uint256 b, string memory errorMessage": 8007, + "Queryable": 8008, + "erc20-": 8009, + "throwError": 8010, + ");\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function ": 8011, + "newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n ": 8012, + "(address sender, address recipient, uint256 amount": 8013, + " in the ": 8014, + "C ": 8015, + "bb": 8016, + "go ": 8017, + "hsi": 8018, + "thus ": 8019, + "to != ": 8020, + "byte": 8021, + "TotalSupply": 8022, + " <0.8.0": 8023, + "++i": 8024, + ".\\n *\\n * This function call ": 8025, + "████████": 8026, + "See the corresponding\\n * ": 8027, + "``role``'s admin role": 8028, + "interface defined by\\n * `interfaceId`. See the corresponding\\n * ": 8029, + "Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * ": 8030, + "to learn more about how these ids are created.\\n *\\n * This function call ": 8031, + "to learn more about how these ids are created.\\n *\\n * This function call must use less than 3": 8032, + "136": 8033, + "00 ": 8034, + "onlyOwner {\\n ": 8035, + "removing ": 8036, + "\\u0027s ": 8037, + "compil": 8038, + "rounded down": 8039, + "benefici": 8040, + "(x, y, ": 8041, + "burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer": 8042, + "Does not update the allowance ": 8043, + "condition is to first reduce the spender's ": 8044, + "conflict ": 8045, + " @dev ": 8046, + "Cap": 8047, + "Filter": 8048, + "Get": 8049, + "RAT": 8050, + "); // ": 8051, + "is discourag": 8052, + ".sol\\\";\\r\\n": 8053, + "if (value == 0) {\\n return ": 8054, + "LOW": 8055, + "to\\n * the owner": 8056, + "} from \\\"./": 8057, + "mapping(address => uint256) private _balances": 8058, + "there are no ": 8059, + "`account`.\\n *\\n * If `account` had": 8060, + "modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use ": 8061, + "Reserves": 8062, + "++;\\n temp ": 8063, + "maximum `uint256": 8064, + "Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * ": 8065, + "module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use ": 8066, + "temp = value;\\n uint256 ": 8067, + "\\\";\\n }\\n uint256 temp = value;\\n uint256 ": 8068, + "condition is to first reduce the spender's allowance to 0 and set ": 8069, + "module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner": 8070, + "\"Transfer ": 8071, + "1; ": 8072, + "Nft": 8073, + ", usually ": 8074, + "date": 8075, + " to prevent ": 8076, + " of the contract": 8077, + "amount must be greater than ": 8078, + "est way to ": 8079, + "reserveIn": 8080, + "_addressData": 8081, + "caller is not owner nor ": 8082, + "at the beginn": 8083, + "MINTED": 8084, + "Fee = _": 8085, + "OperatorFilterRegistry": 8086, + "\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=": 8087, + "destin": 8088, + "By default, the owner account will be the one that deploys the contract. This\\n * ": 8089, + "transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n ": 8090, + "Penalty": 8091, + "USD": 8092, + "address data": 8093, + "\\n *\\r\\n * ": 8094, + "\"ERC20: burn from the zero address\"": 8095, + "\\\\x19": 8096, + ";\\n }\\n\\n /**\\n * @dev Returns the number of ": 8097, + "}\\n * event": 8098, + "Interface of the ERC20 standard as defined in the EIP": 8099, + "Sets `amount` as the allowance of `spender` over the caller's ": 8100, + ";\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner": 8101, + "mm": 8102, + "Amount ": 8103, + "cket": 8104, + "as it ": 8105, + "must be\\n * ": 8106, + ",\\n uint256 quantity": 8107, + "pointer ": 8108, + "For example, ": 8109, + "al representation.\\n */\\n function toHexString": 8110, + "Pos++": 8111, + "_LENGTH": 8112, + "r` and `": 8113, + "reser": 8114, + "even ": 8115, + ";\\n } else {": 8116, + "Consecuti": 8117, + "SellTaxAt": 8118, + "details.": 8119, + "\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner": 8120, + "leavesL": 8121, + "startTokenId, quantity": 8122, + "affect": 8123, + "232": 8124, + "Found": 8125, + "[i": 8126, + "].\\n */\\n function ": 8127, + "calc": 8128, + "said ": 8129, + "treasury": 8130, + ", Rounding rounding": 8131, + "uint256[] memory": 8132, + "from` must have a balance of at least `amount": 8133, + "s, etc": 8134, + "vention": 8135, + "_initializ": 8136, + "mod 2^256": 8137, + "always ": 8138, + "owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev ": 8139, + "platform": 8140, + "can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner": 8141, + "Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * ": 8142, + "Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner": 8143, + "info": 8144, + "invok": 8145, + "core": 8146, + "tokens.\\n *\\n * ": 8147, + "See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual ": 8148, + "\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.": 8149, + "Finally, ": 8150, + "_development": 8151, + "openzeppelin-contracts/contracts/": 8152, + "VALID": 8153, + "assigns ": 8154, + "Creates `amount` ": 8155, + "don't ": 8156, + "_values": 8157, + "mixed": 8158, + "removeLimits": 8159, + "ExactTokens": 8160, + "(value, ": 8161, + ");\\r\\n }\\r\\n\\r\\n /**\\r\\n * @dev ": 8162, + "bots_": 8163, + "funds ": 8164, + "StorageSlot": 8165, + "JoinExit": 8166, + ") internal virtual {}\\n\\n /**\\n * @dev Hook that is called after ": 8167, + "STAMP": 8168, + "forever ": 8169, + "_START": 8170, + "-name-mixed": 8171, + ");\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n ": 8172, + " P": 8173, + "smart ": 8174, + "added to ": 8175, + "OwnershipData": 8176, + ",\\n uint256 _": 8177, + "dstChainId": 8178, + "(bytes32 role": 8179, + "Packed(\\\"": 8180, + "ByIndex": 8181, + "_reduceSellTaxAt": 8182, + " is Context, IERC20": 8183, + ";\\n emit Approval(owner, spender, amount": 8184, + "Consecutive": 8185, + "();\\n ": 8186, + "Tick": 8187, + "UL": 8188, + "Uint256": 8189, + ") : ": 8190, + "a == ": 8191, + "` tokens ": 8192, + "re of the ": 8193, + "codehash": 8194, + "feeAmount": 8195, + "the caller must have a balance of at least `amount": 8196, + "to\\n * another (`to": 8197, + ") {\\n value /= 10**": 8198, + ";\\n }\\n if (value >= 10**": 8199, + "\"ERC20: burn amount exceeds balance\"": 8200, + "sender,\\n address recipient": 8201, + "address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev ": 8202, + "and/or ": 8203, + "94": 8204, + "`_": 8205, + "a * ": 8206, + "unlock": 8207, + "address oldOwner": 8208, + "los": 8209, + ".\\n *\\n * If ": 8210, + "Of(": 8211, + "String ": 8212, + "using the\\n * ": 8213, + "int256, ": 8214, + "_taxSwapThreshold": 8215, + "`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function ": 8216, + "registry ": 8217, + "owned by `account`.\\n */\\n function ": 8218, + "at least `amount` ": 8219, + "NOTE: This ": 8220, + "offset": 8221, + "address(this).balance": 8222, + "Sets `amount` as the allowance of `spender` over the ": 8223, + "Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner": 8224, + "at the beginning of ": 8225, + "to\\n * another (`to`).\\n *\\n * ": 8226, + "owned by `account`.\\n */\\n function balanceOf(address account": 8227, + "();\\nerror ": 8228, + "b5": 8229, + "\\n\\n ": 8230, + "reset": 8231, + ", see ": 8232, + "amount, \\\"ERC20: ": 8233, + "a short": 8234, + "spi": 8235, + ".\\n */\\n function allowance(address owner, address spender": 8236, + "allowances for ": 8237, + "events": 8238, + "bytes32 private ": 8239, + "encodePacked": 8240, + "balance of `": 8241, + "1 : 0": 8242, + "((((": 8243, + "less than smallest ": 8244, + "oldOwner, newOwner": 8245, + "dividing by ": 8246, + "CodeHash": 8247, + "currentAllowance = allowance(owner, spender": 8248, + ".\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value": 8249, + "See {IERC20-approve}.": 8250, + "Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value": 8251, + "`value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * ": 8252, + "allowance of a `spender` for an `owner` is set by\\n * a ": 8253, + "Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract ": 8254, + "`value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value": 8255, + "_ID": 8256, + "succ": 8257, + "values for ": 8258, + ".\\n */\\n function update": 8259, + "subsystem": 8260, + "error == ": 8261, + "Mintable": 8262, + "decimals` ": 8263, + "result := ": 8264, + "srcChainId": 8265, + "trait": 8266, + "We have ": 8267, + "Locked": 8268, + "internal function is equivalent to `approve": 8269, + "(address registrant, address ": 8270, + "certain subsystem": 8271, + "in existence.\\n */\\n function totalSupply() external view returns (uint256": 8272, + "OwnershipTransferred(oldOwner, newOwner": 8273, + "eq(": 8274, + ");\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a ": 8275, + "FixedPoint": 8276, + ". See the note ": 8277, + "_allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount": 8278, + "address oldOwner = _owner": 8279, + "allowances for certain subsystem": 8280, + "`value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a ": 8281, + "internal function is equivalent to `approve`, and ": 8282, + ". See the note at the beginning of ": 8283, + "allowances for certain subsystems, etc": 8284, + " to": 8285, + "'t": 8286, + "CH": 8287, + "join": 8288, + "v0.5.": 8289, + "uint256 ID of the token": 8290, + "of these ": 8291, + "(address payable ": 8292, + "ation.\\n *\\n * ": 8293, + ");\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecim": 8294, + "0x20": 8295, + "the caller of ": 8296, + ".\\n */\\n function _burn": 8297, + "set automatic ": 8298, + ",\\n uint256 ": 8299, + ".\\n if (": 8300, + "present.\\n */\\n function ": 8301, + "safeTransferFrom} ": 8302, + "was successful": 8303, + "defined in ": 8304, + "? 1 : 0": 8305, + "BITPOS_EXTRA_DATA": 8306, + "maxWalletSize": 8307, + "series": 8308, + "required by the EIP": 8309, + "aware of the ": 8310, + "using the\\n * allowance mechanism. `amount` is then deducted ": 8311, + "in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens ": 8312, + "`value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance": 8313, + "set automatic allowances for certain subsystems, etc": 8314, + "dd": 8315, + "\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729": 8316, + "fromBlock": 8317, + "ing mechanisms": 8318, + "of contract ": 8319, + "required": 8320, + "token fees": 8321, + "s[i": 8322, + "packOwnershipData": 8323, + "nextExtraData": 8324, + "must have allowance for ": 8325, + "implementation is ": 8326, + "approvals": 8327, + "RAX": 8328, + ", slash": 8329, + "solidity-utils/": 8330, + "(address(0), to, startTokenId, quantity": 8331, + "789": 8332, + "automatic token fees": 8333, + "transfer}, and ": 8334, + "\\\\xe3\\\\x81": 8335, + "internal function is equivalent to {transfer}, and ": 8336, + "desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729": 8337, + "tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded": 8338, + "owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev ": 8339, + ". See the note at the beginning of {ERC20": 8340, + "required by the EIP. See the note at the beginning of {ERC20": 8341, + "ing mechanisms, etc": 8342, + ", slashing mechanisms, etc": 8343, + "automatic token fees, slashing mechanisms, etc": 8344, + "(bytes": 8345, + "-R": 8346, + "100000000": 8347, + "\\tu": 8348, + "just ": 8349, + "= true": 8350, + "address is ": 8351, + "bool) {\\n return ": 8352, + "ulner": 8353, + ".\\n *\\n * `": 8354, + ".\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function ": 8355, + ", please ": 8356, + "set once ": 8357, + " {\\n using ": 8358, + "marketingFee": 8359, + "spender` must have allowance for ": 8360, + ">> _": 8361, + ");\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` ": 8362, + "implement automatic token fees, slashing mechanisms, etc": 8363, + "crv": 8364, + "is\\n * zero by default": 8365, + "DefaultRoyalty": 8366, + "low level ": 8367, + "anymore": 8368, + "range": 8369, + "ONE_20": 8370, + "set._inner, bytes32": 8371, + "malleable ": 8372, + "(\\n address owner,\\n address spender,\\n uint256 amount\\n ": 8373, + "CAUTION: ": 8374, + "in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev ": 8375, + ".\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom": 8376, + "spender` must have allowance for the caller of ": 8377, + ");\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * ": 8378, + "is\\n * zero by default.\\n *\\n * This ": 8379, + "(0, ": 8380, + ".\\r\\n ": 8381, + "IO": 8382, + "vulner": 8383, + "uint256) private ": 8384, + "\\n * transaction ordering. One possible solution to mitigate this rac": 8385, + "\\n * that someone may use both the old and the new allowance by unfortunate": 8386, + "pped": 8387, + "convention": 8388, + "s.\\n */\\nlibrary ": 8389, + "(\\n address indexed ": 8390, + ");\\n\\n /**\\n * @dev Moves `amount` tokens from ": 8391, + "uint256) {\\n return _totalSupply": 8392, + "the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729": 8393, + "reserveOut": 8394, + "Params": 8395, + "tokens and assigns ": 8396, + "second": 8397, + "string(abi.encodePacked(": 8398, + "Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate": 8399, + "allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This ": 8400, + ");\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This ": 8401, + "\\n * transaction ordering. One possible solution to mitigate this race\\n * ": 8402, + "Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * ": 8403, + "(from": 8404, + "];\\n }\\n\\n /**\\n * @dev ": 8405, + "fac": 8406, + "{\\n uint256 ": 8407, + "value == 0": 8408, + ") public onlyOwner {\\n ": 8409, + "Fees[": 8410, + "rawAmount": 8411, + "AndCall": 8412, + "argument": 8413, + "set._values": 8414, + "$$$$": 8415, + "Privat": 8416, + ".\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * ": 8417, + "TypedDataV4": 8418, + "Enabled = ": 8419, + "approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from ": 8420, + "updAd": 8421, + "value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender": 8422, + "\\n *\\n * Emits an {Approval} event.\\n */\\n function ": 8423, + "tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * ": 8424, + "spender` must have allowance for the caller of at least": 8425, + "the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function ": 8426, + ");\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender": 8427, + "-encod": 8428, + "dy": 8429, + "{\\n ": 8430, + "int128": 8431, + "//\\n // ": 8432, + "it's ": 8433, + "\\\";\\n ": 8434, + "TokenTo": 8435, + "token transfer": 8436, + "== false": 8437, + "SwapFeePercentage": 8438, + "the call ": 8439, + "isApprovedForAll(owner, ": 8440, + "\"Address: insufficient ": 8441, + "}.\\n *\\n * NOTE: ": 8442, + ");\\n }\\n }\\n\\n ": 8443, + "Revokes ": 8444, + "3456": 8445, + ".\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value": 8446, + "negative": 8447, + "_TIMESTAMP": 8448, + "tokens and assigns them to ": 8449, + "the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from ": 8450, + "/=lib/": 8451, + "3 ": 8452, + "IGN": 8453, + "ed for ": 8454, + "er version of ": 8455, + ") internal returns (bool) {\\n return _": 8456, + "` to transfer ": 8457, + "Paused ": 8458, + "has an ": 8459, + "get its ": 8460, + "tokenId uint256 ID of the token": 8461, + "(bytes32 hash": 8462, + ") external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender": 8463, + ", \\\"ERC20: decreased allowance below zero": 8464, + "` must have at least `amount` ": 8465, + "`account`, increas": 8466, + "ZZZZZZZZZZZZZZZZ": 8467, + "NSFER_": 8468, + "bitrary ": 8469, + "Creates `amount` tokens and assigns them to ": 8470, + "`value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value": 8471, + "`\\n * - `": 8472, + "a new ": 8473, + " = _msgSender(": 8474, + "for each ": 8475, + "123456": 8476, + "itelist ": 8477, + "⣿⣿⣿⣿": 8478, + "that\\n * ": 8479, + "nCheckpoints": 8480, + "a - b": 8481, + "Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner": 8482, + "Creates `amount` tokens and assigns them to `account`, increas": 8483, + " OPERATIONS\\n // =============================================================\\n\\n /**\\n * @dev ": 8484, + "2);\\n ": 8485, + "Rate ": 8486, + "_liquidity": 8487, + "s can call ": 8488, + "attack": 8489, + "exit": 8490, + " to another ": 8491, + "logBytes": 8492, + "Time ": 8493, + "digest": 8494, + "END": 8495, + "symbol of the token, usually ": 8496, + "` functions anymore": 8497, + "123456789": 8498, + "symbol of the token, usually a short": 8499, + "` functions anymore. ": 8500, + "3d": 8501, + "Sp": 8502, + "lic": 8503, + "ness ": 8504, + "n't": 8505, + "ind ": 8506, + "or(": 8507, + "Reveal": 8508, + "requires ": 8509, + "burned by ": 8510, + ".length == ": 8511, + "subtractedValue, \\\"ERC20: decreased allowance below zero": 8512, + ") {\\n require(value <= type(": 8513, + "uint256, reverting on\\n * overflow (when the input is ": 8514, + "decimals used to ": 8515, + "abcdef": 8516, + ") external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev ": 8517, + "uint256, reverting on\\n * overflow (when the input is greater than largest ": 8518, + "Ol": 8519, + "kk": 8520, + "inside ": 8521, + "isEx": 8522, + "\\\");\\r\\n\\r\\n ": 8523, + "Replac": 8524, + "lier": 8525, + "value to be ": 8526, + "AllFee": 8527, + " is emitted ": 8528, + "ethel": 8529, + "nonethel": 8530, + "SwapAndLiquify": 8531, + "general ": 8532, + "Usage of ": 8533, + "`role` from ": 8534, + "utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev ": 8535, + "detailed ": 8536, + "\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev ": 8537, + "[to]": 8538, + "behavior is ": 8539, + "operator, approved": 8540, + "voting power ": 8541, + " @dev Creates `amount` tokens and assigns them to `account`, increas": 8542, + "spired by ": 8543, + "Revokes `role` from ": 8544, + "symbol of the token, usually a shorter version of ": 8545, + "(Counter storage ": 8546, + "Base ": 8547, + "`tokenId": 8548, + "wrapp": 8549, + "toMask": 8550, + "increase": 8551, + ": they ": 8552, + "member ": 8553, + "that contract recipient": 8554, + ") external view returns (uint256 ": 8555, + ";\\n ": 8556, + "abi.encodeWithSelector": 8557, + "OpenZeppelin": 8558, + "has to be ": 8559, + "an {Approval} event": 8560, + "`. A": 8561, + "tokens from being ": 8562, + "_msgSender()][spender": 8563, + "first that contract recipient": 8564, + "downcasted": 8565, + "user representation": 8566, + "ERC721 protocol": 8567, + ") internal virtual {}\\n}\\n\"": 8568, + "Days": 8569, + ") external view returns (bool);\\n}\\n\"": 8570, + "from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to ": 8571, + "_allowances[_msgSender()][spender": 8572, + "ed to a user ": 8573, + "well-": 8574, + "removed from the ": 8575, + "checking first that contract recipient": 8576, + "ECDSA: invalid signature ": 8577, + "owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to ": 8578, + ",\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ": 8579, + "forever locked": 8580, + "aware of the ERC721 protocol": 8581, + "get its user representation": 8582, + "decimals used to get its user representation": 8583, + "(Counter storage counter": 8584, + "tokens from being forever locked": 8585, + " it": 8586, + "66": 8587, + "X96": 8588, + "trading ": 8589, + "\\n inverse *= 2 - denominator * inverse; // inverse mod 2^": 8590, + "isn't ": 8591, + "ardi": 8592, + "In ": 8593, + "sender` must have a balance of at least `amount": 8594, + "Signer": 8595, + "amount <= ": 8596, + "s\\n * are ": 8597, + "make the ": 8598, + "unchecked {\\n ": 8599, + ")\\n\\n // ": 8600, + "{\\n /**\\n * @dev Returns true if ": 8601, + "1,\\n ": 8602, + "5` (`": 8603, + "Sum": 8604, + "_display": 8605, + "ait": 8606, + "care ": 8607, + "***": 8608, + "a balance of `": 8609, + "account` must have at least `amount` ": 8610, + "be display": 8611, + "events, ": 8612, + "@@@": 8613, + "Address, ": 8614, + "burn(uint256 tokenId": 8615, + "`, a balance of `": 8616, + "returndata;\\n } else {": 8617, + "initializer": 8618, + "_ purpos": 8619, + ".\\r\\n *\\r\\n * Requirements:\\r\\n *\\r": 8620, + "es: it ": 8621, + "equals `": 8622, + "\\n\\t * ": 8623, + "information is only ": 8624, + "used for _display": 8625, + "if `decimals` ": 8626, + "arithmetic of the contract": 8627, + "For example, if `decimals` ": 8628, + "` tokens should": 8629, + "ed to a user as `": 8630, + "be displayed to a user as `": 8631, + "_ purposes: it ": 8632, + "information is only used for _display": 8633, + "For example, if `decimals` equals `": 8634, + "information is only used for _display_ purposes: it ": 8635, + "e9": 8636, + "s).\\n *\\n * ": 8637, + "\\n ) internal {\\n ": 8638, + "t for a ": 8639, + ");\\n\\n event ": 8640, + "of the arithmetic of the contract": 8641, + ".\\n *\\n * Emits an {": 8642, + "ERC721A ": 8643, + "gas cost": 8644, + "no way ": 8645, + ") internal pure returns (uint256) {\\n uint256 result = ": 8646, + "modifier only": 8647, + "} and {IERC20-": 8648, + "Fund": 8649, + ".selector, ": 8650, + "Primary": 8651, + "Dividends": 8652, + " FOR ": 8653, + "underlying ": 8654, + "separately": 8655, + "allPairs": 8656, + "draft-": 8657, + "s any of the arithmetic of the contract": 8658, + "affects any of the arithmetic of the contract": 8659, + "no way affects any of the arithmetic of the contract": 8660, + "=\\n ": 8661, + "Lev": 8662, + "a4": 8663, + "r := ": 8664, + ", '": 8665, + "\\\",\\\"": 8666, + "\\n\\n // ": 8667, + "OwnerEnumeration": 8668, + "in case ": 8669, + "of the token": 8670, + "supported. ": 8671, + "\\u0026": 8672, + ";\\n }\\n\\n // =============================================================\\n // ": 8673, + "}\\r\\n\\r\\n ": 8674, + "ight ": 8675, + "uniqu": 8676, + ", so we ": 8677, + "swapExactETHForTokensSupportingFeeOnTransferTokens": 8678, + "\"// SPDX-License-Identifier: GPL-3.0-or-later": 8679, + "Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20": 8680, + "using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance": 8681, + "utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\"": 8682, + "well-known ": 8683, + ".\\n // ": 8684, + "the non-": 8685, + "ERC20 is Context, IERC20": 8686, + "{\\n // ": 8687, + "result + (": 8688, + "Taxes": 8689, + "useful": 8690, + "code is ": 8691, + "IMPLEMENT": 8692, + "tokenId + ": 8693, + "Sets the values for ": 8694, + "EVENT": 8695, + "can only be set once ": 8696, + "relationship betwe": 8697, + "(\\n ": 8698, + "();\\n return ": 8699, + "2`, a balance of `": 8700, + "SH": 8701, + "iev": 8702, + "softwa": 8703, + "wik": 8704, + "\\n //": 8705, + ", imit": 8706, + "trans": 8707, + "tokenOfOwner": 8708, + "opcode": 8709, + "opt for a ": 8710, + "and Wei": 8711, + "false` ": 8712, + ", bytes32 value": 8713, + "Tokens usually ": 8714, + "allowance for all ": 8715, + "expectation": 8716, + " / 10 ** 2": 8717, + "Set storage set, bytes32 value": 8718, + " may not ": 8719, + "immutable: they ": 8720, + "505` tokens should": 8721, + "505 / 10 ** 2": 8722, + "values are immutable: they ": 8723, + "Ether and Wei": 8724, + "ating the relationship betwe": 8725, + "value of 18, imit": 8726, + "in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account": 8727, + "5` (`505 / 10 ** 2": 8728, + "be displayed to a user as `5": 8729, + "For example, if `decimals` equals `2`, a balance of `": 8730, + "Level": 8731, + "using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom": 8732, + "opt for a value of 18, imit": 8733, + "Tokens usually opt for a value of 18, imit": 8734, + "values are immutable: they can only be set once ": 8735, + "For example, if `decimals` equals `2`, a balance of `505` tokens should": 8736, + "Tokens usually opt for a value of 18, imitating the relationship betwe": 8737, + ", // ": 8738, + "TokenFrom": 8739, + "and does not ": 8740, + "This allows ": 8741, + "raw ": 8742, + "`.\\n *\\n * WARNING: ": 8743, + "given token ID": 8744, + "DEAD": 8745, + ") public virtual override returns (bool) {\\n address owner = _msgSender();\\n ": 8746, + "> 0, \\\"": 8747, + "Interface for the ": 8748, + ">= amount, \\\"ERC20: transfer ": 8749, + "For a detailed ": 8750, + "limitsInEffect": 8751, + "We can directly ": 8752, + "conflict with the ": 8753, + "tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set ": 8754, + "no way affects any of the arithmetic of the contract, includ": 8755, + "tokenOfOwnerByIndex": 8756, + "values are immutable: they can only be set once dur": 8757, + "Element": 8758, + "RANT": 8759, + "^ ": 8760, + "less": 8761, + ", data": 8762, + "agnos": 8763, + ";\\n _owner = newOwner": 8764, + "operator for ": 8765, + "when dividing by ": 8766, + "uint8(": 8767, + "\\n\\npragma solidity ^0.7.0": 8768, + "safeTransferFrom(from, to, tokenId": 8769, + "owner or ": 8770, + ";\\n emit OwnershipTransferred(oldOwner, newOwner": 8771, + "calculate": 8772, + "uint24 ": 8773, + "If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function ": 8774, + "token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function ": 8775, + "Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set ": 8776, + "address oldOwner = _owner;\\n _owner = newOwner": 8777, + "Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from ": 8778, + "address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner": 8779, + "vs": 8780, + "ening to ": 8781, + "ed general ": 8782, + "a value ": 8783, + "by list": 8784, + "added in a ": 8785, + "on calls to ": 8786, + "balanceOf} and {IERC20-": 8787, + "lines: ": 8788, + "tic to the ": 8789, + "s to reconstruct the ": 8790, + ". This behavior is ": 8791, + "implementations of the ": 8792, + "\\r\\n function ": 8793, + "these events, ": 8794, + "followed general ": 8795, + "{IERC20-balanceOf} and {IERC20-": 8796, + ". Other ": 8797, + "applications to reconstruct the ": 8798, + "OUT ": 8799, + "tokens are created": 8800, + "\\\");\\r\\n require(": 8801, + "guarantee": 8802, + "guidelines: ": 8803, + "required by the specification": 8804, + "LpBurn": 8805, + "_removeTokenFrom": 8806, + "latest/": 8807, + "fields ": 8808, + "Boole": 8809, + "derived contract ": 8810, + "on failure. This behavior is ": 8811, + "events. Other ": 8812, + "We have followed general ": 8813, + " is emitted on calls to ": 8814, + "result + (rounding == Rounding.Up && ": 8815, + "Sets the values for {": 8816, + "false` on failure. This behavior is ": 8817, + "allowance for all accounts ": 8818, + "expectations of ": 8819, + "by listening to ": 8820, + "these events, as it ": 8821, + "{IERC20-balanceOf} and {IERC20-transfer": 8822, + "applications to reconstruct the allowance for all accounts ": 8823, + "guidelines: functions ": 8824, + "events. Other implementations of the ": 8825, + "false` on failure. This behavior is nonethel": 8826, + "=\\u003e ": 8827, + "NE": 8828, + "{decreaseAllowance": 8829, + "relies ": 8830, + "a : ": 8831, + "return c": 8832, + "This method ": 8833, + "This implementation is ": 8834, + "with custom message ": 8835, + ";\\n\\n mapping(address => ": 8836, + "@param to ": 8837, + "))\\n ": 8838, + ":= add(": 8839, + "Stage": 8840, + "way tokens are created": 8841, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\"": 8842, + "lpPair": 8843, + "supply mechanism ": 8844, + "mitigate the ": 8845, + "until": 8846, + ". This includes ": 8847, + "that a supply mechanism ": 8848, + ")\\n public\\n view": 8849, + "at a time": 8850, + "issues around ": 8851, + "Out ": 8852, + "erc721a": 8853, + "Additionally, an {Approval} event": 8854, + "Position": 8855, + "Finally, the non-": 8856, + "added to mitigate the ": 8857, + "has to be added in a ": 8858, + "well-known issues around ": 8859, + "agnostic to the ": 8860, + "Sets the values for {name": 8861, + "This implementation is agnostic to the ": 8862, + "way tokens are created. This ": 8863, + "that a supply mechanism has to be added in a ": 8864, + "Additionally, an {Approval} event is emitted on calls to ": 8865, + "Finally, the non-standard ": 8866, + "added to mitigate the well-known issues around ": 8867, + "This implementation is agnostic to the way tokens are created. This ": 8868, + "that a supply mechanism has to be added in a derived contract ": 8869, + "Media": 8870, + "returning `": 8871, + ") {\\r\\n ": 8872, + "for which ": 8873, + "not revert": 8874, + "string public ": 8875, + "EIP may not ": 8876, + "Mode": 8877, + "supply-": 8878, + "following\\n * ": 8879, + "} and {increaseAllowance": 8880, + ".sol\\\";\\nimport \\\"../../../": 8881, + "keccak256(bytes(": 8882, + "(uint256 value) internal pure returns (string memory) {\\n ": 8883, + "i.e. `": 8884, + "using {_mint": 8885, + "more expensive ": 8886, + "much ": 8887, + "said events. Other implementations of the ": 8888, + "ConsecutiveTransfer": 8889, + "of these values are immutable: they can only be set once dur": 8890, + "Ether and Wei. This is the ": 8891, + "and does not conflict with the ": 8892, + "This allows applications to reconstruct the allowance for all accounts ": 8893, + "by listening to said events. Other implementations of the ": 8894, + "{decreaseAllowance} and {increaseAllowance": 8895, + "Finally, the non-standard {decreaseAllowance} and {increaseAllowance": 8896, + "that a supply mechanism has to be added in a derived contract using {_mint": 8897, + "returning `false` on failure. This behavior is nonethel": 8898, + "EIP may not emit": 8899, + "and does not conflict with the expectations of ": 8900, + "This allows applications to reconstruct the allowance for all accounts just": 8901, + "by listening to said events. Other implementations of the EIP may not emit": 8902, + "-erc20-": 8903, + "[How": 8904, + "];\\n\\n ": 8905, + "due ": 8906, + "{_": 8907, + "ergen": 8908, + "uint256) {\\r\\n ": 8909, + "ailed": 8910, + "\\r\\n *": 8911, + "ContractOnERC721Received": 8912, + "Ownable ": 8913, + "implement-erc20-": 8914, + "allowances. ": 8915, + "SafeMath for uint256": 8916, + "using `": 8917, + "_balances[recipient": 8918, + "functions have been ": 8919, + "delegates": 8920, + "up see ": 8921, + ") external;\\n\\n /**\\n * @dev Returns the ": 8922, + "mechanisms/2": 8923, + "writeup see ": 8924, + "ILITY": 8925, + "/// @solidity memory-safe-assembly\\n assembly {\\n ": 8926, + "how-to-": 8927, + "Role(role, account);\\n }\\n\\n /**\\n * @dev ": 8928, + "Implementation of the {IERC20": 8929, + "t/how-to-": 8930, + "Key": 8931, + "Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. ": 8932, + "IMPLEMENTATION": 8933, + "For a detailed writeup see ": 8934, + "Additionally, an {Approval} event is emitted on calls to {transferFrom": 8935, + "added to mitigate the well-known issues around setting": 8936, + "supply-mechanisms/2": 8937, + "implement-erc20-supply-mechanisms/2": 8938, + "functions have been added to mitigate the well-known issues around setting": 8939, + "t/how-to-implement-erc20-supply-mechanisms/2": 8940, + "For a detailed writeup see our ": 8941, + "t/how-to-implement-erc20-supply-mechanisms/226": 8942, + "_receiver": 8943, + "catch": 8944, + "hold ": 8945, + "pe": 8946, + "rate ": 8947, + ");\\n }\\n": 8948, + "item": 8949, + "` in packed ": 8950, + "node": 8951, + "TransferCallerNotOwnerNorApproved": 8952, + "bug": 8953, + "totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (": 8954, + "buyback": 8955, + "Min,\\n uint amount": 8956, + "s to be ": 8957, + "implement supply ": 8958, + "the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount": 8959, + "keccak256(abi.encodePacked(\\\"": 8960, + "fixed point ": 8961, + "For a generic ": 8962, + ") {\\n if (success": 8963, + "TIP: For a detailed writeup see our ": 8964, + "protect against ": 8965, + "Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing ": 8966, + ") external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from ": 8967, + "allowances. See {IERC20-approve}.": 8968, + "Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing ": 8969, + "t/how-to-implement-erc20-supply-mechanisms/226[How": 8970, + "implement supply mechanisms": 8971, + "For a generic mechanism ": 8972, + "TIP: For a detailed writeup see our guide": 8973, + "62": 8974, + "KS": 8975, + "an\\n * ": 8976, + "ERC1967": 8977, + "(address to": 8978, + "while": 8979, + "Inspired by ": 8980, + ") public override ": 8981, + "when they are ": 8982, + ";\\n string private _symbol": 8983, + "Packed ": 8984, + "signature fields ": 8985, + "11/": 8986, + "_transferOwnership(address newOwner": 8987, + "OrRegistr": 8988, + "receives the `": 8989, + "} and {symbol": 8990, + "prevOwnershipPacked ": 8991, + "} that receives the `": 8992, + "subscriptionOrRegistr": 8993, + "range ": 8994, + " of {ECDSA-": 8995, + "string private _name;\\n string private _symbol": 8996, + "Overload of {ECDSA-": 8997, + "123456789abcdef": 8998, + "Sets the values for {name} and {symbol": 8999, + "For a generic mechanism see {": 9000, + "signature fields separately": 9001, + "subscriptionOrRegistrant": 9002, + "Vo": 9003, + "╠╠": 9004, + " * _": 9005, + ", IERC721": 9006, + "tokens.": 9007, + "ToZeroAddress": 9008, + "view returns(": 9009, + "AddressSet storage set": 9010, + "Exp": 9011, + "remainder ": 9012, + "UintSet storage set": 9013, + "weight": 9014, + "Points": 9015, + "Sets `amount` as the allowance of `spender` over the `owner` s ": 9016, + "21": 9017, + "WAP": 9018, + "_base": 9019, + "betwe": 9020, + "}) ": 9021, + "uint224": 9022, + "256 bits ": 9023, + "the contract ": 9024, + "value >>= ": 9025, + "payout": 9026, + "allowance}.\\n */\\n function ": 9027, + "tokens.\\n *\\n * This ": 9028, + "PerToken": 9029, + ") private returns (bool) {\\n ": 9030, + "block.chainid": 9031, + "_Available since v3.": 9032, + "_SIGN": 9033, + "(tokenId, ": 9034, + "lastTokenId": 9035, + "amount exceeds the ": 9036, + "unsigned integer ": 9037, + "ZeroQuantity": 9038, + "return true;\\n }\\n\\n /**\\n * @dev ": 9039, + "access/Ownable.sol\"": 9040, + "concat": 9041, + "proposal": 9042, + " ? a : ": 9043, + "Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n ": 9044, + "Window": 9045, + "bul": 9046, + "factor": 9047, + "w.": 9048, + "for `": 9049, + "if (b": 9050, + "on error": 9051, + ".\\n */\\n function _approve": 9052, + "decimals() external view returns (": 9053, + "Min,\\n address to,\\n uint deadline": 9054, + " < _": 9055, + ".\\n *\\n * Requirements:\\n *\\n * - the caller must have ": 9056, + "safeTransferFrom}\\n * ": 9057, + "deprec": 9058, + "amount0Out": 9059, + ");\\n }\\n }\\n\\n /**\\n * @dev Returns the ": 9060, + "oracle": 9061, + ");\\n return result + (rounding == Rounding.Up && ": 9062, + ") internal pure returns (uint256) {\\n unchecked {\\n uint256 result = ": 9063, + "accept": 9064, + ", Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = ": 9065, + "AI": 9066, + "\\n * greater than largest ": 9067, + "\\n\\n struct ": 9068, + "owner` cannot be the zero address.\\n * - `": 9069, + "\\n * function ": 9070, + "token id ": 9071, + "address(0) ": 9072, + "abilities": 9073, + "(\\n address to": 9074, + "hash of the ": 9075, + "transferFrom}": 9076, + "\\\\__": 9077, + "total number of tokens ": 9078, + "IERC721Receiver(to).": 9079, + "ANY ": 9080, + "ABILITY": 9081, + "_transferOwnership(newOwner": 9082, + "_allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-": 9083, + "reverting on\\n * overflow (when the input is less than smallest ": 9084, + "OperationsFee": 9085, + ";\\n\\n uint256 private _totalSupply": 9086, + ".\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `": 9087, + "gas.\\n */\\n function supportsInterface(bytes4 interfaceId": 9088, + "int256, reverting on\\n * overflow (when the input is less than smallest ": 9089, + "updAds": 9090, + "owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount": 9091, + "IMPLEMENTATION_SLOT": 9092, + "().": 9093, + "9b": 9094, + "FI": 9095, + "FX": 9096, + "SET": 9097, + "asset ": 9098, + "uint liquidity": 9099, + "ight": 9100, + "}\\n }\\n\\n /**\\n * @dev Returns the ": 9101, + ";\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function ": 9102, + "WARRANT": 9103, + ".\\n */\\n constructor() {\\n ": 9104, + "Price ": 9105, + "Cache": 9106, + "transfer}.\\n *\\n * Requirements:\\n *\\n * - `": 9107, + "];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `": 9108, + ");\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function ": 9109, + "Basic": 9110, + "_approve(_msgSender(), spender, ": 9111, + "}(\\\"\\\");\\n require(": 9112, + "existing when they are ": 9113, + ".\\n ": 9114, + "bt": 9115, + "inc": 9116, + "uint256(_": 9117, + "====\\n */\\n function ": 9118, + ": hex ": 9119, + "ForETH": 9120, + "blockTimestamp": 9121, + ">= value": 9122, + "numberBurned": 9123, + "Counters.": 9124, + "_balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `": 9125, + "Strings: hex ": 9126, + ".\\n * - the caller must have a balance of at least `amount": 9127, + "Reverts ": 9128, + "length insufficient": 9129, + "paused(": 9130, + "Strings: hex length insufficient": 9131, + ".\\n * - the caller must have a balance of at least `amount`.\\n */\\n function ": 9132, + "_callOptionalReturn": 9133, + "here ": 9134, + "ler": 9135, + "decod": 9136, + "\\\"\\\"": 9137, + "ayout": 9138, + "Index[tokenId": 9139, + ")\\n {\\n return ": 9140, + "stored at ": 9141, + ".\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is ": 9142, + "can be used to\\n * e.g. set automatic allowances for certain subsystems, etc": 9143, + "not\\n * required by the EIP. See the note at the beginning of {ERC20": 9144, + "Software ": 9145, + "internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc": 9146, + "decimals() external view returns (uint8": 9147, + "transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is ": 9148, + "transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20": 9149, + "(address": 9150, + ").\\n */\\n function _": 9151, + "1.": 9152, + "500": 9153, + "_RE": 9154, + "uint256)": 9155, + ") returns (": 9156, + "FeeTotal": 9157, + "newAllowance": 9158, + "update ": 9159, + ":= sub(": 9160, + "`.\\n * - the caller must have allowance for ": 9161, + ";\\n }\\n if (": 9162, + "uint64(": 9163, + "number of tokens in ": 9164, + "_Available since v4.1._": 9165, + "spender` cannot be the zero address.\\n */\\n function _approve": 9166, + "call to non-contract\"": 9167, + "packedAddressData[owner": 9168, + "_devFee": 9169, + "sale ": 9170, + "can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc": 9171, + "total supply.\\n *\\n * Emits a {Transfer} event with `from` ": 9172, + "reducing the\\n * ": 9173, + "requency": 9174, + "internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc": 9175, + "uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function ": 9176, + "Boolean": 9177, + "between ": 9178, + ".\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve": 9179, + "internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve": 9180, + "2.0": 9181, + "mid": 9182, + "sort": 9183, + "wra": 9184, + "\\n * ": 9185, + "bly ": 9186, + " of a ": 9187, + ");\\n }\\n\\n /// @notice ": 9188, + "bytes4(": 9189, + "(token.": 9190, + ");\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20": 9191, + "www.": 9192, + "total supply.\\n *\\n * Emits a {Transfer} event with `to` ": 9193, + "reentrancy vulner": 9194, + "trigge": 9195, + "ing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` ": 9196, + ";\\n\\n // The bit position of `": 9197, + "reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` ": 9198, + "internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer": 9199, + "_, ": 9200, + "s.\\n *\\n * ": 9201, + "itself": 9202, + ");\\n emit ": 9203, + ";\\n\\nimport {": 9204, + "Permit ": 9205, + "`, `": 9206, + "` cannot be the zero address.\\n * - `account` must have at least `amount` ": 9207, + "_burnCounter": 9208, + "Check ": 9209, + "`.\\n */\\n function _transfer": 9210, + "notbot": 9211, + "claimed": 9212, + "previous owner": 9213, + "Holding": 9214, + "keep": 9215, + "serv": 9216, + "tokens of at least\\n * `amount`.\\n */\\n function transferFrom": 9217, + "OWN": 9218, + "compliant ": 9219, + " @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` ": 9220, + "-call": 9221, + "_ref": 9222, + "esc": 9223, + " = keccak256(\\\"": 9224, + ";\\n\\nimport '": 9225, + "link": 9226, + "Payout": 9227, + "Loan": 9228, + "the\\n * name": 9229, + "address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n ": 9230, + "1;\\n }\\n ": 9231, + ";\\n }\\n\\n ": 9232, + "ed, use {": 9233, + "amount1Out": 9234, + "spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20": 9235, + "this method is discourag": 9236, + "_status": 9237, + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically de": 9238, + "domain separator ": 9239, + ", since the ": 9240, + "spender` must have allowance for the caller of at least\\n * `": 9241, + "Usage of this method is discourag": 9242, + "symbol of the token, usually a shorter version of the\\n * name": 9243, + "` cannot be the zero address.\\n * - `account` must have at least `amount` tokens": 9244, + "Usage of this method is discouraged, use {": 9245, + "_user": 9246, + "increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance": 9247, + "iform": 9248, + "if present": 9249, + "newBalance": 9250, + "dibly ": 9251, + ");\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to": 9252, + ".\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `": 9253, + "_tFeeTotal": 9254, + " from uint256, reverting on\\n * overflow (when the input is greater than largest ": 9255, + "incredibly ": 9256, + "typeHash": 9257, + ") internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount": 9258, + "```solidity": 9259, + "drop ": 9260, + ".\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_": 9261, + "creases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `": 9262, + "token/ERC721/extensions/IERC721Metadata": 9263, + "_roles": 9264, + ");\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` ": 9265, + "_COMP": 9266, + "whenever possible": 9267, + "ExcludeFromFees": 9268, + "taken to not ": 9269, + "RecoverError error": 9270, + ");\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender": 9271, + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `": 9272, + "symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol": 9273, + "` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn": 9274, + "increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function ": 9275, + "incredibly unrealis": 9276, + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `": 9277, + "E = ": 9278, + "PC ": 9279, + "ial": 9280, + "mark": 9281, + "uint256[] calldata ": 9282, + "exchang": 9283, + "whitelist ": 9284, + "maxTxAmount": 9285, + "this library ": 9286, + "Returns if the ": 9287, + "subtractedValue`.\\n */\\n function ": 9288, + ";\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol": 9289, + ".\\n //": 9290, + "isContract(address account": 9291, + "percentage ": 9292, + "PART": 9293, + "zero.\\n *\\n * Counterpart to Solidity's `": 9294, + "mint to the zero address\\\");\\n\\n _beforeTokenTransfer": 9295, + "_msgSenderERC721A())": 9296, + "out of bound": 9297, + "success ": 9298, + "abi.encodeWithSelector(token.": 9299, + "This implementation is agnostic to the way tokens are created. This means\\n * ": 9300, + "For a generic mechanism see {ERC20PresetMinterPauser": 9301, + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function ": 9302, + "JB": 9303, + "TX": 9304, + "`hash": 9305, + "sw": 9306, + "}).\\n *\\n * ": 9307, + ", ERC165": 9308, + "mag": 9309, + "TransferFrom": 9310, + "\\n * these events, as it ": 9311, + "\\n * by listening to said events. Other implementations of the EIP may not emit": 9312, + "IERC20(": 9313, + ";\\n\\n string private _name;\\n string private _symbol": 9314, + ",\\n address indexed ": 9315, + "MINT_": 9316, + "`.\\n *\\n * See {": 9317, + "`operator` ": 9318, + "applications.\\n *\\n * ": 9319, + "oost": 9320, + "lower 160": 9321, + "early": 9322, + ") public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-": 9323, + "queue": 9324, + "`recipient`, ": 9325, + "} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * ": 9326, + "amountToSwapForETH": 9327, + "Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n ": 9328, + "This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit": 9329, + "uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account": 9330, + "} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint": 9331, + "This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it ": 9332, + "54": 9333, + "A0": 9334, + "Ear": 9335, + "LIC": 9336, + "or remove ": 9337, + "Trading ": 9338, + "voc": 9339, + "E_HASH": 9340, + "Checker": 9341, + "possibly ": 9342, + ", uint p3) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(": 9343, + "Beacon": 9344, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6": 9345, + "}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it ": 9346, + "transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be ": 9347, + "complex": 9348, + ")\\\", p0, p1, p2));\\n\\t}\\n\\n\\tfunction log(": 9349, + "expiry": 9350, + ")) private _allowances;\\n\\n uint256 private _totalSupply": 9351, + "(int256 value) internal pure returns (int": 9352, + "throwError(": 9353, + "required by the specification.\\n *\\n * ": 9354, + "Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint": 9355, + "Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it ": 9356, + "functions have been added to mitigate the well-known issues around setting\\n * ": 9357, + "increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue": 9358, + "applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it ": 9359, + "Borrow": 9360, + "T256": 9361, + "/**\\n * @dev ": 9362, + "bytes1": 9363, + "that will be ": 9364, + "currently ": 9365, + ").interfaceId": 9366, + "_owners": 9367, + "` cannot be the caller": 9368, + "\\\\ ": 9369, + "gence": 9370, + "Aux": 9371, + ";\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name": 9372, + "iru": 9373, + "insufficient allowance": 9374, + "a / b": 9375, + "correctly ": 9376, + "}\\n * functions have been added to mitigate the well-known issues around setting\\n * ": 9377, + "}.\\n *\\n * TIP: For a detailed writeup see our guide": 9378, + "\\n * https://forum.": 9379, + "\\n * to implement supply mechanisms": 9380, + "(account, address(0), amount);\\n }\\n\\n /**\\n * @dev ": 9381, + "Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * ": 9382, + "t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms": 9383, + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue": 9384, + "required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * ": 9385, + "}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.": 9386, + "t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * ": 9387, + "required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.": 9388, + "1e18": 9389, + "57": 9390, + "Kee": 9391, + "_O": 9392, + "b7": 9393, + "\\n * ": 9394, + "lik": 9395, + "and(": 9396, + "ing\\n * construction": 9397, + "such that ": 9398, + "`tokenId` token to another ": 9399, + "ves permission": 9400, + "half": 9401, + " to `to` to transfer ": 9402, + "0.6.0 <0.8.0": 9403, + "burn from the zero address\\\");\\n\\n _beforeTokenTransfer": 9404, + "(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer": 9405, + "(address(0), account, amount);\\n\\n _totalSupply ": 9406, + "-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data": 9407, + "s from the previous owner": 9408, + "Gives permission": 9409, + "additionalPayee": 9410, + "_START_TIMESTAMP": 9411, + "`.\\n *\\n * WARNING: Usage of this method is discouraged, use {": 9412, + "}(\\\"\\\");\\n require(success": 9413, + "Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * ": 9414, + "`tokenId` token to another account": 9415, + " to `to` to transfer `tokenId` token to another account": 9416, + "Gives permission to `to` to transfer `tokenId` token to another account": 9417, + " amount ": 9418, + "1B": 9419, + "M ": 9420, + "_verifyCallResult": 9421, + "s) ": 9422, + "re: ": 9423, + "\\n * be displayed to a user as `5": 9424, + "exact ": 9425, + "lying": 9426, + "loop": 9427, + "Address for ": 9428, + "May ": 9429, + ".\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should": 9430, + "+= 1": 9431, + "SellFee": 9432, + "timestamp of ": 9433, + "registry": 9434, + ");\\n }\\n }\\n}\\n\"": 9435, + "Finish": 9436, + "s with a ": 9437, + "override returns (bool) {\\n return interfaceId == type(": 9438, + "ood ": 9439, + "`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship betwe": 9440, + ".\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount": 9441, + "5` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship betwe": 9442, + "burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n ": 9443, + ".\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5": 9444, + "ins": 9445, + "input": 9446, + "\\\")": 9447, + "return value": 9448, + "AddressSlot": 9449, + "partic": 9450, + "logic": 9451, + "_transfer(from, to, tokenId": 9452, + "pragma solidity 0.6.": 9453, + "URI ": 9454, + "\\n // @param _": 9455, + ")\\\", p0));\\n\\t}\\n\\n\\tfunction ": 9456, + "ERC721AQueryable": 9457, + "s a value ": 9458, + "address,string,": 9459, + "address,bool,": 9460, + "p0) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(": 9461, + " := sub(": 9462, + "UintSet": 9463, + "token/ERC721/IERC721Receiver": 9464, + "staking": 9465, + ")\\\", p0, p1, p2, p3));\\n\\t}\\n\\n\\tfunction log(uint ": 9466, + "****************************************************************": 9467, + "product": 9468, + "_ENTRY": 9469, + "_transferOwnership(_msgSender()": 9470, + "_DATA_ENTRY": 9471, + "BITMASK_ADDRESS_DATA_ENTRY": 9472, + "in\\n * no way affects any of the arithmetic of the contract, includ": 9473, + "`isContract` will ": 9474, + "Subtraction ": 9475, + ");\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` ": 9476, + ";\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation": 9477, + "information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, includ": 9478, + "required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ": 9479, + "5` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * ": 9480, + ";\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5": 9481, + "(address(": 9482, + ".*": 9483, + "At ": 9484, + "Gas ": 9485, + "ND": 9486, + "_account": 9487, + "restore": 9488, + "use the ": 9489, + "spl": 9490, + "that it ": 9491, + "ested": 9492, + ") {\\n revert(\\\"": 9493, + "}.\\n */\\n function decimals": 9494, + "firm": 9495, + "[`eth_sign": 9496, + "Added": 9497, + "ing\\n * {IERC20-balanceOf} and {IERC20-transfer": 9498, + "AUS": 9499, + "BITPOS_START_TIMESTAMP": 9500, + "royalties": 9501, + "`operator` to ": 9502, + "Short": 9503, + "Releas": 9504, + "(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n ": 9505, + "BITPOS_NUMBER_MINTED": 9506, + "Calculates ": 9507, + ".startTimestamp": 9508, + "consider": 9509, + "Performs a ": 9510, + "upgradeable/": 9511, + "(token, abi.encodeWithSelector(token.": 9512, + "amount must be greater than zero\"": 9513, + "address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\"": 9514, + "of these values are immutable: they can only be set once during\\n * construction": 9515, + "(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply ": 9516, + "information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer": 9517, + "information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals": 9518, + "-and-": 9519, + "69": 9520, + "://": 9521, + "FRAX": 9522, + "c8": 9523, + "dation": 9524, + "hop": 9525, + "publ": 9526, + ".\\n *\\n * Only ": 9527, + "sig": 9528, + "minter ": 9529, + "redistribu": 9530, + "token owned by ": 9531, + "bool private ": 9532, + " != address(0)": 9533, + "account can be ": 9534, + "Development": 9535, + "token ID ": 9536, + "result is negative": 9537, + "distributed ": 9538, + "clean": 9539, + "(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` ": 9540, + "Royalties": 9541, + "Collection of ": 9542, + "Foundation": 9543, + "a * b": 9544, + "s previous ": 9545, + "20 ": 9546, + "account.\\n */\\n function ": 9547, + "igno": 9548, + "RECI": 9549, + "store the ": 9550, + "uint256) {\\n // ": 9551, + "verify ": 9552, + "licens": 9553, + "\\\");\\n _;\\n }\\n\\n /**\\n * @dev ": 9554, + "types of ": 9555, + "Delete": 9556, + "\"Transfer amount must be greater than zero\"": 9557, + ");\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-": 9558, + "increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n ": 9559, + "5` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the ": 9560, + "RECISION": 9561, + "();": 9562, + ".addr": 9563, + "each": 9564, + "reward ": 9565, + "address clear": 9566, + ",\\n InvalidSignature": 9567, + "for this ": 9568, + "termin": 9569, + "bytes32[] calldata ": 9570, + "pot": 9571, + "import \\\"./": 9572, + "Operators can call ": 9573, + "Consi": 9574, + "modulo": 9575, + "approved at a time": 9576, + "napshot ": 9577, + "`operator` cannot be the caller": 9578, + "{transferFrom} or {": 9579, + "as an operator for ": 9580, + "redemp": 9581, + "a single account can be ": 9582, + ", so approv": 9583, + "You should ": 9584, + "tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer": 9585, + "Approve or remove ": 9586, + "https://solidity.readthedocs.io/en/latest/": 9587, + "approval is cleared when the token is transferred": 9588, + "for any token owned by ": 9589, + "`operator` as an operator for ": 9590, + "address clears previous ": 9591, + "Operators can call {transferFrom} or {": 9592, + "approved at a time, so approv": 9593, + "a single account can be approved at a time, so approv": 9594, + "Approve or remove `operator` as an operator for ": 9595, + "for any token owned by the caller": 9596, + "Approve or remove `operator` as an operator for the caller": 9597, + " been ": 9598, + "),\\n * ": 9599, + "0,\\n ": 9600, + "No ": 9601, + "v ": 9602, + "er's ": 9603, + "verifi": 9604, + "000000": 9605, + "openzeppelin.com/": 9606, + "implementation, ": 9607, + "(1 << ": 9608, + "Zero ": 9609, + "does not exist": 9610, + "Artist": 9611, + "details": 9612, + "from` and `to` are never both zero": 9613, + "Removed": 9614, + "square ": 9615, + "manage all of the ": 9616, + "security/ReentrancyGuard": 9617, + "Blacklisted": 9618, + "incip": 9619, + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n ": 9620, + "Consider ": 9621, + " TH": 9622, + "),\\n \\\"": 9623, + "`,": 9624, + "strict": 9625, + ".\\n */\\n function _transferOwnership(address newOwner": 9626, + "Amount = ": 9627, + "redisFee": 9628, + "] != ": 9629, + "Upgrad": 9630, + "`.\\n * ": 9631, + "SetAutomatedMarketMakerPair": 9632, + ".\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `": 9633, + "Active ": 9634, + "Prevent": 9635, + "` is allowed to manage all of the ": 9636, + "tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve": 9637, + "iform ": 9638, + "` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n ": 9639, + "Returns if the `operator": 9640, + ")) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol": 9641, + "` is allowed to manage all of the assets ": 9642, + ",\\n// ": 9643, + "ule": 9644, + "{\\r\\n ": 9645, + "increases the ": 9646, + "token to ": 9647, + "function that ": 9648, + "ages": 9649, + "These ": 9650, + "it will be ": 9651, + "ligence": 9652, + "{\\n if (": 9653, + "URPOS": 9654, + "INVALID": 9655, + "FFSET": 9656, + ",\\n address from": 9657, + "Proxy ": 9658, + "\\\\ ": 9659, + "E_P": 9660, + "gas limit": 9661, + "functions relat": 9662, + "set._indexes[": 9663, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9": 9664, + "multiplication": 9665, + "format": 9666, + "{ERC20} ": 9667, + "].sub(amount, \\\"ERC20: ": 9668, + ".\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply ": 9669, + "bytes16 ": 9670, + "Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve": 9671, + "Collection of functions relat": 9672, + "Returns if the `operator` is allowed to manage all of the assets ": 9673, + "Returns if the `operator` is allowed to manage all of the assets of `owner": 9674, + "BURNED": 9675, + "s pattern": 9676, + "returns the ": 9677, + "\\n function set": 9678, + "who": 9679, + "Main": 9680, + "\\n * - `from` and `to` are never both zero": 9681, + " is transferred to ": 9682, + "abi-encod": 9683, + "modify": 9684, + "igh ": 9685, + "Only": 9686, + ".\\n * Operators can call {transferFrom} or {": 9687, + "interface ID": 9688, + "must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this ": 9689, + "\\n * @return ": 9690, + "ApprovalForAll} event.\\n */\\n function ": 9691, + "account approved for ": 9692, + "owner || ": 9693, + ", bytes32 r": 9694, + "/// @author ": 9695, + ".\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator": 9696, + ".\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller": 9697, + "work ": 9698, + "stop-": 9699, + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this ": 9700, + "under the ": 9701, + "BITPOS_NUMBER_BURNED": 9702, + ".\\n * The approval is cleared when the token is transferred": 9703, + "Get the ": 9704, + "Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner": 9705, + "consen": 9706, + ".\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function ": 9707, + "_COMPLEMENT": 9708, + "Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred": 9709, + ".\\n *\\n * Only a single account can be approved at a time, so approv": 9710, + "address clears previous approvals": 9711, + "for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller": 9712, + "Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {": 9713, + "Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approv": 9714, + "fa": 9715, + "war": 9716, + "yIndex": 9717, + "is already ": 9718, + "a different ": 9719, + "usd": 9720, + "sure ": 9721, + "2019": 9722, + "s.net": 9723, + "(\\n address token": 9724, + "hashTypedDataV4": 9725, + "collateral ": 9726, + "pair ": 9727, + "gas and ": 9728, + "Upgradeable ": 9729, + ",\\n address ": 9730, + "never ": 9731, + "control is transferred to ": 9732, + "variables.": 9733, + "removeLiquidityETHWithPermit": 9734, + "integer division": 9735, + "(address payable recipient, uint256 amount": 9736, + "isContract(address account) internal view returns (bool": 9737, + ", bytes32 r, bytes32 ": 9738, + ".\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator": 9739, + "(amount": 9740, + "IENT": 9741, + "Pending": 9742, + "RU": 9743, + "units": 9744, + "art": 9745, + "\\n assembly {\\n ": 9746, + "sys.net": 9747, + ") {\\n require(": 9748, + "Identifier ": 9749, + "sends `amount` ": 9750, + "select ": 9751, + "will be created": 9752, + "uses a `": 9753, + "revert reason and ": 9754, + "salePrice": 9755, + "math/SafeMath": 9756, + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev ": 9757, + "security-": 9758, + " bits, ": 9759, + "in the set. O(1).\\n */\\n function ": 9760, + "convert to ": 9761, + "(bool success, ) = recipient": 9762, + "(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n ": 9763, + "concaten": 9764, + "For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.": 9765, + "Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.": 9766, + "consideration": 9767, + "account.\\n */\\n function balanceOf(address owner": 9768, + "DeleteIndex": 9769, + "consensys.net": 9770, + "uses a `revert": 9771, + "%` operator": 9772, + ".onERC721Received.selector": 9773, + "/` operator": 9774, + "IERC2981": 9775, + "sstore": 9776, + ", use {": 9777, + ") and not ": 9778, + "@dev Returns the ": 9779, + "no-in": 9780, + "return false ": 9781, + "decimal ": 9782, + "s[owner": 9783, + "URI) ": 9784, + "MaxSupply": 9785, + "Process": 9786, + "line-assembly": 9787, + ";\\n\\n /**\\n * @dev Sets the values for {name} and {symbol": 9788, + "Solidity uses ": 9789, + "ADesired": 9790, + "] += amount": 9791, + "enum ": 9792, + "` must be a contract": 9793, + "ers can ": 9794, + "pause(": 9795, + "making them ": 9796, + ");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom": 9797, + "domainSeparatorV4": 9798, + "QUID": 9799, + "opcode (which leaves remaining gas untouched) while Solidity uses ": 9800, + "division by zero. The result is rounded toward": 9801, + ". This function uses a `revert": 9802, + "go over the ": 9803, + "`.\\n *\\n * See {setApprovalForAll": 9804, + "%` operator. This function uses a `revert": 9805, + "no-inline-assembly": 9806, + "division by zero. The result is rounded towards ": 9807, + "0\"": 9808, + "high ": 9809, + "now ": 9810, + "}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function ": 9811, + "` array": 9812, + "of an ": 9813, + "shif": 9814, + ". Consider ": 9815, + "the-": 9816, + "utils/cryptography/": 9817, + ".\\n * - `tokenId` must exist": 9818, + " << _": 9819, + "`tokenId` will be\\n * ": 9820, + "must be `": 9821, + "denominator) ": 9822, + "IMUM": 9823, + "uint256 public constant ": 9824, + "tokenByIndex": 9825, + "by\\n * ": 9826, + ".\\n *\\n * Emits an {Approval} event.\\n */\\n function ": 9827, + "();\\n\\n /**\\n * Cannot ": 9828, + ").interfaceId ||\\n ": 9829, + "registered": 9830, + "_exists(tokenId), \\\"ERC721: ": 9831, + ");\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner": 9832, + "owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ": 9833, + "global-": 9834, + "();\\n\\n /**\\n * The token ": 9835, + "`tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved": 9836, + "minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer": 9837, + "transferred to `to`.\\n * - When `from` is zero, `tokenId` will be ": 9838, + "WITHOUT ": 9839, + "\\u003e= ": 9840, + "Early": 9841, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (": 9842, + "transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer": 9843, + "applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't ": 9844, + "(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve": 9845, + "publish": 9846, + "strictly ": 9847, + "Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll": 9848, + "account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved": 9849, + "for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator": 9850, + "`tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be ": 9851, + ");\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n ": 9852, + "owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf": 9853, + "(unsigned integer ": 9854, + "(URI) ": 9855, + "HANT": 9856, + "MERC": 9857, + "xC": 9858, + "refund": 9859, + "uint256) {\\r\\n return ": 9860, + "to assume that ": 9861, + "721 ": 9862, + "ERC721Metadata": 9863, + "Among ": 9864, + "lived": 9865, + "address(uint160(": 9866, + ", \\\"\\\"": 9867, + "Uniform ": 9868, + "using memory ": 9869, + "use-": 9870, + "Resource ": 9871, + "ERC721A__": 9872, + "Stable": 9873, + "was destroy": 9874, + " from int256, reverting on\\n * overflow (when the input is less than smallest ": 9875, + "account (EOA": 9876, + "others, ": 9877, + ", but was destroy": 9878, + "Asset ": 9879, + "a contract in construction": 9880, + "MINTER_ROLE": 9881, + "----------------------------------------------------------------": 9882, + "sendValue(address payable recipient, uint256 amount": 9883, + "false is ": 9884, + "Learn ": 9885, + "Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * ": 9886, + "unsafe to assume that ": 9887, + "It is unsafe to assume that ": 9888, + "an externally-owned account": 9889, + "unable to send value, recipient may have reverted": 9890, + "Equivalent to `": 9891, + "ers. (unsigned integer ": 9892, + "remainder of dividing two unsigned integers. (unsigned integer ": 9893, + "NESS": 9894, + "square root ": 9895, + "security-consideration": 9896, + "Among others, ": 9897, + "lived, but was destroy": 9898, + "Uniform Resource ": 9899, + "account (EOA) and not ": 9900, + "Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be ": 9901, + "It is unsafe to assume that an address ": 9902, + "remainder of dividing two unsigned integers. (unsigned integer modulo": 9903, + "-now": 9904, + "/09": 9905, + "/stop-": 9906, + "[checks-effects-interaction": 9907, + "mate": 9908, + "{sendValue": 9909, + ") < ": 9910, + "ed up ": 9911, + ": use ": 9912, + "Idx": 9913, + "transfer`, ": 9914, + "transfer`. ": 9915, + "transfer`: ": 9916, + "transfer-now": 9917, + "stash": 9918, + "} remove": 9919, + "diligence": 9920, + "ITNESS": 9921, + "This function is ": 9922, + "burnFrom": 9923, + "+ amount": 9924, + "s, possibly ": 9925, + "s-pattern": 9926, + "s-transfer-now": 9927, + "Pod": 9928, + "https://eips.ethereum.org/EIPS/eip-1884": 9929, + "reverting on error": 9930, + ".sol\\\";\\n\\n/**\\n * @dev Interface for the ": 9931, + "\\n ///": 9932, + "soliditys-transfer-now": 9933, + "this function returns": 9934, + "writt": 9935, + "available gas and ": 9936, + "wei to": 9937, + "because it ": 9938, + "because control is transferred to ": 9939, + "[EIP1884": 9940, + "contracts go over the ": 9941, + "ReentrancyGuard} or ": 9942, + "using-soliditys-transfer-now": 9943, + "uint112 ": 9944, + "ing all available gas and ": 9945, + "2300 ": 9946, + "Solidity function call": 9947, + "imposed by `": 9948, + "Modifier ": 9949, + "unable to receive ": 9950, + "making contracts go over the ": 9951, + "certain opcode": 9952, + "an externally-owned account (EOA) and not ": 9953, + "checks-effects-interactions-pattern": 9954, + "forwarding all available gas and ": 9955, + "create reentrancy vulner": 9956, + "s this limit": 9957, + "/[Learn ": 9958, + "s.html#use-": 9959, + "funds vi": 9960, + "Replacement for ": 9961, + "for which this function returns": 9962, + " ? a : b;\\n }\\n\\n /**\\n * @dev Returns the ": 9963, + "abilities. Consider ": 9964, + "taken to not create reentrancy vulner": 9965, + "`recipient`, care ": 9966, + "`isContract` will return false ": 9967, + "(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account": 9968, + "types of addresses": 9969, + "increases the gas cost": 9970, + ".\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist": 9971, + "address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist": 9972, + "2019/09": 9973, + "Identifier (URI) ": 9974, + "sends `amount` wei to": 9975, + "consensys.net/": 9976, + "making them unable to receive ": 9977, + "the-checks-effects-interactions-pattern": 9978, + "applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ": 9979, + "false is an externally-owned account (EOA) and not ": 9980, + "security-considerations.html#use-": 9981, + "Among others, `isContract` will return false ": 9982, + "Uniform Resource Identifier (URI) ": 9983, + "It is unsafe to assume that an address for which this function returns": 9984, + "/stop-using-soliditys-transfer-now": 9985, + "[checks-effects-interactions pattern": 9986, + "{sendValue} remove": 9987, + "transfer`, making them unable to receive ": 9988, + "transfer`. {sendValue} remove": 9989, + "transfer`: sends `amount` wei to": 9990, + "s, possibly making contracts go over the ": 9991, + "because control is transferred to `recipient`, care ": 9992, + "2300 gas limit": 9993, + "imposed by `transfer`, making them unable to receive ": 9994, + "certain opcodes, possibly making contracts go over the ": 9995, + "forwarding all available gas and reverting on error": 9996, + "/[Learn more": 9997, + "abilities. Consider using": 9998, + "taken to not create reentrancy vulnerabilities. Consider using": 9999, + "2019/09/stop-using-soliditys-transfer-now": 10000, + "the-checks-effects-interactions-pattern[checks-effects-interactions pattern": 10001, + "security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern": 10002, + "Among others, `isContract` will return false for the ": 10003, + "transfer`. {sendValue} removes this limit": 10004, + "imposed by `transfer`, making them unable to receive funds vi": 10005, + "certain opcodes, possibly making contracts go over the 2300 gas limit": 10006, + "2019/09/stop-using-soliditys-transfer-now/[Learn more": 10007, + "(like ": 10008, + "Free ": 10009, + "Swa": 10010, + "[prod1 ": 10011, + "dou": 10012, + "e6": 10013, + "go": 10014, + "mc": 10015, + "og": 10016, + ", prod0": 10017, + "address type": 10018, + ".\\n */\\n function tokenURI": 10019, + ",\\n address[] calldata path": 10020, + "), returndata_size": 10021, + "provides ": 10022, + "AllTokens": 10023, + "redis": 10024, + "] increases the gas cost": 10025, + "Returns the raw ": 10026, + ", \\\"ERC721: ": 10027, + "License, ": 10028, + "http://": 10029, + "`, checking first that contract recipient": 10030, + "18 ": 10031, + "api/": 10032, + "self ": 10033, + "may not ": 10034, + "][msg.sender": 10035, + "_burnCounter ": 10036, + "\\r\\n /**": 10037, + "ICUL": 10038, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5": 10039, + "let returndata_": 10040, + "mload(returndata": 10041, + "highlight": 10042, + "ed to the address type": 10043, + ");\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev ": 10044, + "_totalSupply -= ": 10045, + "NoError": 10046, + "the calling contract ": 10047, + "revert(add(32, returndata": 10048, + " to prevent tokens from being forever locked": 10049, + "aware of the ERC721 protocol to prevent tokens from being forever locked": 10050, + "Collection of functions related to the address type": 10051, + "`tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to": 10052, + "https://eips.ethereum.org/EIPS/eip-1884[EIP1884": 10053, + "[prod1 prod0": 10054, + "ICULAR": 10055, + "let returndata_size := ": 10056, + "https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost": 10057, + ")\\n // ": 10058, + "ade ": 10059, + "uint _": 10060, + "design": 10061, + "an ETH ": 10062, + ") internal pure returns (string memory) {\\n ": 10063, + "e the revert reason is ": 10064, + "Setting": 10065, + " for revert reason and ": 10066, + "To convert to ": 10067, + "https://eips.ethereum.org/EIPS/eip-712": 10068, + "AllowList": 10069, + "via assembly": 10070, + "A PART": 10071, + "Remain": 10072, + "up if present": 10073, + "_currentIndex - ": 10074, + "wei to ": 10075, + "power of ": 10076, + "with `data` ": 10077, + "bubble it ": 10078, + "bubble the revert reason is ": 10079, + "off-": 10080, + "_addTokenTo": 10081, + "easiest way to ": 10082, + "Look for revert reason and ": 10083, + "HAIN": 10084, + " PURPOS": 10085, + " FOR A PART": 10086, + "_SIGNATUR": 10087, + "_transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n ": 10088, + "QUIDITY": 10089, + "HANTABILITY": 10090, + "MERCHANTABILITY": 10091, + "using memory via assembly": 10092, + "ed up by ": 10093, + "ITNESS FOR A PART": 10094, + "revert(add(32, returndata), returndata_size": 10095, + "let returndata_size := mload(returndata": 10096, + "bubble it up if present": 10097, + "bubble the revert reason is using memory via assembly": 10098, + "easiest way to bubble the revert reason is using memory via assembly": 10099, + "Look for revert reason and bubble it up if present": 10100, + "ITNESS FOR A PARTICULAR": 10101, + "\"Must ": 10102, + "#abi-encod": 10103, + "(), \\\"": 10104, + "-uint256-}[`": 10105, + "=abi.decode": 10106, + "?highlight": 10107, + "_wallet": 10108, + "`call": 10109, + "`abi.decode": 10110, + "functions[": 10111, + "ed Solidity function ": 10112, + "right ": 10113, + "uses, ": 10114, + "byte ": 10115, + "call`. A": 10116, + "- subtractedValue": 10117, + ",\\n bytes memory returndata": 10118, + "ator ": 10119, + "{\\n address ": 10120, + "recipient` cannot be the zero address.\\n * - `": 10121, + "must not revert": 10122, + "numCheckpoint": 10123, + "target` must be a contract": 10124, + "the called Solidity function ": 10125, + "sellFee": 10126, + "Pool's ": 10127, + "ownership.\\n uint256 private constant _": 10128, + "call using a ": 10129, + "use https://solidity.readthedocs.io/en/latest/": 10130, + "must have an ETH ": 10131, + "\\n * `recipient": 10132, + "level `": 10133, + "functionCallWithValue-address-bytes": 10134, + "functionCallWithValue`], ": 10135, + "_setRoleAdmin": 10136, + "also transferring ": 10137, + "-}[`functionCall`], but ": 10138, + "`value` wei to ": 10139, + "balance of at least `value": 10140, + "`target` with `data` ": 10141, + "bubbled up by ": 10142, + "data. To convert to ": 10143, + "calling `target` with `data` ": 10144, + "returned data. To convert to ": 10145, + "Solidity function call using a ": 10146, + "`target` reverts with a ": 10147, + "html?highlight": 10148, + "low level `": 10149, + "ing-and-": 10150, + "ing-functions[": 10151, + "unsafe replac": 10152, + "the expected return value": 10153, + "ement for a function call": 10154, + "revert reason, it is ": 10155, + "regular Solidity function call": 10156, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (": 10157, + "` is an unsafe replac": 10158, + ".\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role": 10159, + "decoding-functions[": 10160, + "Performs a Solidity function call using a ": 10161, + "-and-global-": 10162, + "variables.html?highlight": 10163, + "units-and-global-": 10164, + "must be `payable": 10165, + "(like regular Solidity function call": 10166, + "Returns the raw returned data. To convert to ": 10167, + "the calling contract must have an ETH ": 10168, + "#abi-encoding-and-": 10169, + "-uint256-}[`functionCallWithValue`], ": 10170, + "=abi.decode#abi-encoding-and-": 10171, + "`call` is an unsafe replac": 10172, + "recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount": 10173, + "the called Solidity function must be `payable": 10174, + "use https://solidity.readthedocs.io/en/latest/units-and-global-": 10175, + "functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], ": 10176, + "also transferring `value` wei to ": 10177, + "calling `target` with `data` must not revert": 10178, + "`target` reverts with a revert reason, it is ": 10179, + "low level `call`. A": 10180, + "ement for a function call: use ": 10181, + "decoding-functions[`abi.decode": 10182, + "Performs a Solidity function call using a low level `call`. A": 10183, + "variables.html?highlight=abi.decode#abi-encoding-and-": 10184, + "Returns the raw returned data. To convert to the expected return value": 10185, + "the calling contract must have an ETH balance of at least `value": 10186, + "`call` is an unsafe replacement for a function call: use ": 10187, + "use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-": 10188, + "functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], bu": 10189, + "also transferring `value` wei to `target": 10190, + "`target` reverts with a revert reason, it is bubbled up by ": 10191, + "use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode": 10192, + "FITNESS FOR A PARTICULAR": 10193, + "tree ": 10194, + "amount\\n ) external ": 10195, + "address pair": 10196, + "from != address(0), \\\"": 10197, + ");\\n\\n /// @dev ": 10198, + "revert TransferToNonERC721ReceiverImplementer": 10199, + "\\\");\\n\\n // ": 10200, + "\"@openzeppelin/contracts/access/Ownable.sol\"": 10201, + " bits\"": 10202, + "_getValues": 10203, + "es[role].member": 10204, + "modulo by ": 10205, + ";\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-": 10206, + "keccak256(abi.encodePacked(\\\"\\\\x19": 10207, + ".\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId": 10208, + "address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId": 10209, + "FITNESS FOR A PARTICULAR PURPOS": 10210, + "91": 10211, + "epoch": 10212, + "rTeam": 10213, + "anbul": 10214, + "aster": 10215, + "\\n * }\\n * ```\\n *\\n * ": 10216, + "at `": 10217, + "from != ": 10218, + "] -= ": 10219, + "SwapBack": 10220, + "data to ": 10221, + "supported": 10222, + "lastIndex": 10223, + ") public virtual override {\\n require(": 10224, + "_afterTokenTransfers": 10225, + "ERC20 standard": 10226, + "isApprovedOrOwner": 10227, + "revert(errorMessage": 10228, + ".sol\\\";\\nimport \\\"./extensions/": 10229, + ")\\n }\\n ": 10230, + "_marketingAddress": 10231, + ") public virtual override returns (bool) {\\n _transfer": 10232, + "Data = ": 10233, + "writeCheckpoint": 10234, + "@openzeppelin/contracts-upgradeable/": 10235, + "call with value failed\\\"": 10236, + "OpenZeppelin/": 10237, + "s\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked": 10238, + "Address for address": 10239, + "warrant": 10240, + ");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function ": 10241, + "`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked": 10242, + "uses, unless ": 10243, + " address": 10244, + ")) revert ": 10245, + "@balancer-labs/v2-": 10246, + "Free": 10247, + "bid": 10248, + "arbitrary ": 10249, + "accounts that ": 10250, + "accountBalance = ": 10251, + "spent ": 10252, + ", uint256 _amount": 10253, + "The amount of ": 10254, + "OwnershipAddr": 10255, + "totalSupply() ": 10256, + "auction": 10257, + "\\n */\\r\\n": 10258, + "interface id ": 10259, + "BuyAmount": 10260, + ".length - 1": 10261, + ";\\n\\n emit ": 10262, + "&& !": 10263, + "tiveReserve": 10264, + ", \\\"Address: unable to send value, recipient may have reverted": 10265, + "hasRole(": 10266, + "mstore8": 10267, + "https://github.com/OpenZeppelin/": 10268, + "currOwnershipAddr": 10269, + "ffffffffffffffffffffffffffffffff": 10270, + "token/ERC20/IERC20.sol\"": 10271, + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n // ": 10272, + ", \\\"Address: insufficient balance": 10273, + "1,\\n 1,\\n ": 10274, + "a8": 10275, + "eb": 10276, + "Tool": 10277, + "for `tokenId` token": 10278, + "value {ERC20} ": 10279, + "10))": 10280, + "only stored ": 10281, + "receive the ": 10282, + "LEG": 10283, + "holder ": 10284, + "signatures ": 10285, + "_TRA": 10286, + "lpBurn": 10287, + "you should ": 10288, + ", which returns ": 10289, + "address owner = ERC721.ownerOf(tokenId": 10290, + "MultiProof": 10291, + "QueryForZeroAddress": 10292, + "Grants `role": 10293, + "Presale": 10294, + "(address from, address to, uint256 ": 10295, + ".\\n *\\n * _Available since v4.3._\\n */\\n function ": 10296, + "token collection name": 10297, + "token collection symbol": 10298, + "constructor execution": 10299, + ");\\n\\n // Clear approvals from the previous owner": 10300, + "beneficiary": 10301, + "code is only stored ": 10302, + "This method relies ": 10303, + ", since the code is only stored ": 10304, + "redistribut": 10305, + "(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n ": 10306, + "Uniform Resource Identifier (URI) for `tokenId` token": 10307, + "value {ERC20} uses, unless ": 10308, + ", which returns 0": 10309, + "Grants `role` to ": 10310, + ", since the code is only stored at the end": 10311, + ".delegatecall": 10312, + "].\\n *\\n * IMPORTANT: ": 10313, + "_h": 10314, + "_price": 10315, + "_editionId": 10316, + "capp": 10317, + "ual ": 10318, + "\\n event ": 10319, + "unk": 10320, + "\\n * imposed by `transfer`, making them unable to receive funds vi": 10321, + "to == address(0)": 10322, + "uint256 accountBalance = ": 10323, + "maint": 10324, + "ERC20, ": 10325, + "value, \\\"Address: low-level ": 10326, + ") {\\n if (": 10327, + "ation with ": 10328, + "`, the ": 10329, + "`, forwarding all available gas and reverting on error": 10330, + "set the ": 10331, + "any other ": 10332, + "the\\n * https://solidity.readthedocs.io/en/": 10333, + "(address(0), RecoverError.InvalidSignature": 10334, + "afterTokenTransfers": 10335, + "signature is ": 10336, + "admin role ": 10337, + "encoding ": 10338, + ") {\\n return returndata;\\n } else {": 10339, + "(to, quantity": 10340, + "\\n * {ReentrancyGuard} or ": 10341, + "processMultiProof": 10342, + ">= amount, \\\"ERC20: burn ": 10343, + "} else if (error == ": 10344, + "commun": 10345, + "a\\n * `transfer`. {sendValue} removes this limit": 10346, + "address(this).balance >= amount": 10347, + ", \\\"Address: insufficient balance for call": 10348, + "ERC-721 ": 10349, + "Decre": 10350, + "\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit": 10351, + "\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.6.0 <0.8.0": 10352, + "must be\\n * taken to not create reentrancy vulnerabilities. Consider using": 10353, + "].\\n */\\n function sendValue(address payable recipient, uint256 amount": 10354, + "ation.\\n *\\n * https://": 10355, + "\\\\xe3\\\\x81\\\\x": 10356, + "in case of ": 10357, + "s[owner][operator": 10358, + "transfer`: sends `amount` wei to\\n * `recipient": 10359, + "because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using": 10360, + "security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount": 10361, + "2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: ": 10362, + "Collection of functions related to the address type\\n */\\nlibrary ": 10363, + "\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limit": 10364, + "value, \\\"Address: low-level call with value failed\\\"": 10365, + "`, forwarding all available gas and reverting on errors.\\n *\\n * ": 10366, + "\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/": 10367, + "} else if (error == RecoverError.InvalidSignature": 10368, + "\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limit": 10369, + "transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * ": 10370, + "because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/": 10371, + "2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/": 10372, + "\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://": 10373, + "PRIC": 10374, + "Tow": 10375, + "Use ": 10376, + "\\n * pl": 10377, + "\\n * false is an externally-owned account (EOA) and not ": 10378, + "coold": 10379, + "/**\\r": 10380, + "Sig": 10381, + ".\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract": 10382, + "SellAmount": 10383, + "`.\\n * - the called Solidity function must be `payable": 10384, + ",\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode": 10385, + "`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract": 10386, + "version.": 10387, + ");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], bu": 10388, + ",\\n _": 10389, + ");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but ": 10390, + "currentAllowance >= ": 10391, + "instead.\\n *\\n * If ": 10392, + "144": 10393, + "amount;\\n }\\n\\n emit Transfer": 10394, + ").\\n *\\n * Counterpart to Solidity's `int": 10395, + ".\\n * - calling `target` with `data` must not revert": 10396, + "Royalty ": 10397, + "this\\n * function (like regular Solidity function call": 10398, + "this\\n * function instead.\\n *\\n * If ": 10399, + "(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes": 10400, + "`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value": 10401, + "Old": 10402, + "s).\\n *\\n * Returns the raw returned data. To convert to the expected return value": 10403, + "\\n * greater than largest int": 10404, + "isContract(address account) internal view returns (bool) {\\n // ": 10405, + "It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not ": 10406, + "Among others, `isContract` will return false for the following\\n * ": 10407, + "https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://": 10408, + ",\\n bytes memory returndata,\\n string memory errorMessage\\n ": 10409, + "Performs a Solidity function call using a low level `call`. A\\n * pl": 10410, + "`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If ": 10411, + "also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value": 10412, + "`target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function call": 10413, + "transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://": 10414, + "`.\\n * - the called Solidity function must be `payable`": 10415, + ",\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract": 10416, + ");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * ": 10417, + ");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value": 10418, + ".\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall": 10419, + "s).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract": 10420, + "`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function call": 10421, + ");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`": 10422, + "s).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall": 10423, + "`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall": 10424, + "(uint16 _": 10425, + "). ": 10426, + "\\r\\n ": 10427, + " ": 10428, + "decimal representation.\\n */\\n function ": 10429, + "0 000 ": 10430, + " of two unsigned integers, with an ": 10431, + "\\n * - a contract in construction": 10432, + "\\n * - an externally-owned account": 10433, + "source ": 10434, + "_transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n ": 10435, + "EnumerableSet.": 10436, + ") public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `": 10437, + "a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * ": 10438, + "a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * ": 10439, + ":\\n *\\n * - an externally-owned account": 10440, + ".safeTransferFrom": 10441, + "\\n * - an address where a contract will be created": 10442, + "\\n * - an address where a contract lived, but was destroy": 10443, + "`account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * ": 10444, + "msb(a": 10445, + "2**(k": 10446, + "mulmod(x, y, ": 10447, + "enforc": 10448, + "====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // ": 10449, + "a different value ": 10450, + "select a different value ": 10451, + "types of addresses:\\n *\\n * - an externally-owned account": 10452, + "uint256 accountBalance = _balances[account": 10453, + "Toward ": 10454, + "It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * ": 10455, + "decimal representation.\\n */\\n function toString": 10456, + " of two unsigned integers, with an overflow ": 10457, + "\\n * - a contract in construction\\n * - an address where a contract will be created": 10458, + "_transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n ": 10459, + "`account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * ": 10460, + "types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created": 10461, + "`account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created": 10462, + "`account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroy": 10463, + "!\"": 10464, + "522": 10465, + "big": 10466, + "ordered ": 10467, + "address) private ": 10468, + "valueIndex": 10469, + ") {\\n bytes32 ": 10470, + "if not ": 10471, + "clude ": 10472, + "Sets ": 10473, + "+= quantity": 10474, + "Operators": 10475, + "decimals = ": 10476, + "BPS": 10477, + "distribute": 10478, + "copy of the ": 10479, + "(\\n bytes32 hash": 10480, + "low level call ": 10481, + "{\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroy": 10482, + "erc721a/contracts/": 10483, + "token collection name.\\n */\\n function name": 10484, + "Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI": 10485, + "security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(": 10486, + "*.": 10487, + "Uti": 10488, + "bo": 10489, + "ed by": 10490, + "\\\"H": 10491, + "by bubbl": 10492, + "if (a ": 10493, + "bytes32 indexed ": 10494, + "`from`'s ": 10495, + "ause": 10496, + "184": 10497, + "}\\n return ": 10498, + ") internal view virtual {\\n require(": 10499, + ".\\n if (": 10500, + "() external payable ": 10501, + "_checkContractOnERC721Received": 10502, + "_CHAIN": 10503, + "_DOMAIN_SEPARATOR": 10504, + "spendAllowance(": 10505, + "collateral_": 10506, + "with `errorMessage` as a fallback revert reason when `target` reverts": 10507, + ",\\n uint amountToken": 10508, + ". If ": 10509, + "call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but ": 10510, + "TokenOwnership memory ": 10511, + "accountBalance - amount": 10512, + "0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`": 10513, + "errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall": 10514, + "with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall": 10515, + "was successful, and ": 10516, + "Private ": 10517, + "Replacement for Solidity's `": 10518, + "applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20": 10519, + "AllTokensEnumeration": 10520, + "Tool to ": 10521, + ");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts": 10522, + "call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall": 10523, + "FAC": 10524, + "esting": 10525, + "y = ": 10526, + ");\\r\\n function ": 10527, + "address operator": 10528, + "for all ": 10529, + "IERC20Metadata is ": 10530, + "(from, address(0), tokenId": 10531, + "uint256) {\\n require(": 10532, + ";\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (": 10533, + "swapExactTokensForTokensSupportingFeeOnTransferTokens": 10534, + "return (true, ": 10535, + "half order": 10536, + "override returns (bool) {\\n return _": 10537, + "address(this).balance >= value": 10538, + "_balances[account] = accountBalance - amount": 10539, + "Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _transferOwnership(_msgSender()": 10540, + "}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted": 10541, + "warranty ": 10542, + ", \\\"Address: insufficient balance\\\");\\n\\n ": 10543, + "Decrease": 10544, + ";\\n }\\n": 10545, + "rely ": 10546, + "onus": 10547, + "TokenRoyalty": 10548, + ") external override ": 10549, + "value /= 10": 10550, + "can only ": 10551, + ".\\n */\\n function _check": 10552, + "{\\n require(msg.sender == ": 10553, + "expi": 10554, + ");\\n ": 10555, + ";\\n }\\n require(": 10556, + ") / 2": 10557, + "iod ": 10558, + "packedOwnershipOf(tokenId": 10559, + " ": 10560, + ".\\n *\\n * Requirements:\\n *\\n * - The contract ": 10561, + "_INT256": 10562, + "\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * pl": 10563, + "to != address(0), \\\"ERC20: ": 10564, + ") internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\"": 10565, + "(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n require(b": 10566, + "}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * pl": 10567, + "/solidity": 10568, + "97": 10569, + "Bo": 10570, + "_min": 10571, + "drn": 10572, + ", Errors.": 10573, + "pull": 10574, + "(address =\\u003e ": 10575, + ". For ": 10576, + "at most ": 10577, + "Addresses": 10578, + "on extcodesize": 10579, + "0x5": 10580, + "INS": 10581, + "result < ": 10582, + ".length; i++) {\\n ": 10583, + "MINIMUM": 10584, + "oci": 10585, + "solmate": 10586, + "Info.": 10587, + "them to `to": 10588, + "subscribe": 10589, + "signer = ": 10590, + "hasRole": 10591, + "Metadata {\\n ": 10592, + "reentrant ": 10593, + "Rele": 10594, + "decimals places ": 10595, + "free softwa": 10596, + "exemptfrom": 10597, + "upper bits ": 10598, + "using the provided ": 10599, + "_indexes": 10600, + "received a ": 10601, + ") internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev ": 10602, + "uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `": 10603, + "constructor execution.\\n": 10604, + "This method relies on extcodesize": 10605, + ") internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts": 10606, + "Growth": 10607, + "MY": 10608, + "must": 10609, + "ee: ": 10610, + "newAddress": 10611, + "(\\n address sender,\\n address recipient": 10612, + "abi.encodePacked(": 10613, + "directly": 10614, + "Created": 10615, + "Throws if the ": 10616, + "ggle": 10617, + "computing ": 10618, + "shl(": 10619, + "\\n }\\n }\\n }\\n ": 10620, + "flash ": 10621, + "String operation": 10622, + "_CHAIN_ID": 10623, + "IERC20Metadata is IERC20": 10624, + "Ea": 10625, + "_move": 10626, + ", address[] calldata path": 10627, + "uint256 _": 10628, + "left": 10629, + "look": 10630, + "\\n * @notice ": 10631, + "value ? 1 : 0": 10632, + "transfer amount exceeds the ": 10633, + "iven": 10634, + "store ": 10635, + "Txn": 10636, + "should only be ": 10637, + "final ": 10638, + "amountsIn": 10639, + "withdrawn": 10640, + "s `quantity` ": 10641, + "dividend": 10642, + "encoded ": 10643, + ", as defined in ": 10644, + "\\\"0123456789abcdef": 10645, + "_unchain": 10646, + "_init_unchain": 10647, + "v0.5.11/": 10648, + "subscriptionOrRegistrantToCopy": 10649, + "http://www.": 10650, + "address(this).balance >= value, \\\"Address: insufficient balance for call": 10651, + "decimals places of the token": 10652, + " address ": 10653, + ".consensys.net/": 10654, + "2d": 10655, + "Vi": 10656, + "_spendAllowance": 10657, + "f8": 10658, + ", following the selected rounding direction": 10659, + "ed.": 10660, + "roz": 10661, + "ingContract": 10662, + "\\n assembly {\\n ": 10663, + "a g": 10664, + "` or ": 10665, + "getRoleMember": 10666, + "(\\n address operator": 10667, + ") private {\\n // ": 10668, + "Burned ": 10669, + ");\\n require(\\n ": 10670, + "unchecked {\\r\\n ": 10671, + "transfers them to `to": 10672, + "map._": 10673, + "purposes": 10674, + "Governor": 10675, + "tokens and transfers them to `to": 10676, + "helper": 10677, + "\\n\\n// This program is ": 10678, + "3333333333333333": 10679, + "Secondary": 10680, + "posts/": 10681, + ") internal view returns (bytes memory) {\\n return ": 10682, + "amountToBurn": 10683, + "Status": 10684, + "declare ": 10685, + ". Since ": 10686, + "_packedOwnerships[nextTokenId": 10687, + "If the next slot ": 10688, + "LpBurnTime": 10689, + "diligence.consensys.net/": 10690, + "Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://": 10691, + ";\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `": 10692, + "diligence.consensys.net/posts/": 10693, + "3 of the ": 10694, + "pty": 10695, + "smar": 10696, + " *\\r\\n * ": 10697, + "artist": 10698, + "\\\"x": 10699, + ");\\n // ": 10700, + "Admin ": 10701, + "es = ": 10702, + "Cost": 10703, + "implied ": 10704, + "proper": 10705, + "contract that ": 10706, + "the\\n // ": 10707, + "Empty": 10708, + "to, amount": 10709, + "0, // ": 10710, + "any later ": 10711, + "}.\\n */\\ninterface ": 10712, + "need ": 10713, + ">> 128": 10714, + "burned` to `": 10715, + "(owner, address(0), tokenId": 10716, + "(uint256 value, uint256 ": 10717, + "(from, to, tokenId, _data": 10718, + "BITMASK_NEXT_INITIALIZED": 10719, + "Domain": 10720, + "uint8 v, bytes32 r, bytes32 ": 10721, + "` to the timestamp of ": 10722, + " + 1; i": 10723, + "startTimestamp` to the timestamp of ": 10724, + "nextInitialized` to `": 10725, + "ProtocolFee": 10726, + "overridden": 10727, + "seconds": 10728, + ") internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call": 10729, + "https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section": 10730, + ") {\\n if (success) {\\n return returndata;\\n } else {": 10731, + "value >>= 4": 10732, + "WARRANTY": 10733, + "Software Foundation": 10734, + "strictly less than ": 10735, + "from != address(0), \\\"ERC20: ": 10736, + "address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n ": 10737, + "0 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId": 10738, + "security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n ": 10739, + "using the provided one": 10740, + "s `quantity` tokens and transfers them to `to": 10741, + "uint8 v, bytes32 r, bytes32 s": 10742, + " B": 10743, + ")) {\\n ": 10744, + "Aver": 10745, + "Gated": 10746, + "_percent": 10747, + "ps ": 10748, + "ted": 10749, + "try ": 10750, + "emergen": 10751, + "getPair": 10752, + "Emits a {Transfer": 10753, + "feeDenominator": 10754, + "withdrawable": 10755, + "greater than 0": 10756, + "(a, b": 10757, + "Function": 10758, + ", which can then ": 10759, + "often ": 10760, + "accountBalance >= amount, \\\"ERC20: burn ": 10761, + "owner of the given token ID": 10762, + "isExcludedFromFees": 10763, + "1] = \\\"x": 10764, + "value == 0, \\\"": 10765, + "t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general ": 10766, + "2 * length": 10767, + "[value ": 10768, + "aren": 10769, + "fill": 10770, + "u.org/": 10771, + "}\\n */\\n function ": 10772, + "rid": 10773, + "--i": 10774, + "gnu.org/": 10775, + "] `": 10776, + "104": 10777, + "ed by other": 10778, + "been already ": 10779, + "buffer[0] = ": 10780, + "MAX_SUPPLY": 10781, + "toHexString(value, ": 10782, + "revokeRole(bytes32 role, address account": 10783, + "for (uint256 i = 2": 10784, + "[0-": 10785, + "LOG": 10786, + "functionStaticCall(target, data, \\\"Address: low-level ": 10787, + "Pausable: ": 10788, + "array of ": 10789, + "set._inner": 10790, + "Comm": 10791, + "buffer[i": 10792, + "buffer[1] = \\\"x": 10793, + "AGE": 10794, + " * length + 1; i": 10795, + "version 3 of the ": 10796, + "balanceOf(address(this)": 10797, + "bytes memory buffer = new bytes(2 * length": 10798, + "uint8) {\\n return 18": 10799, + "1; --i": 10800, + "licenses/": 10801, + "incipal": 10802, + "under the term": 10803, + "Free Software Foundation": 10804, + ", as defined in the\\n * ": 10805, + "value == 0, \\\"Strings: hex length insufficient": 10806, + "buffer[0] = \\\"0": 10807, + "for (uint256 i = 2 * length + 1; i": 10808, + "functionStaticCall(target, data, \\\"Address: low-level static ": 10809, + "bytes memory buffer = new bytes(2 * length + ": 10810, + "]{": 10811, + "histor": 10812, + "made ": 10813, + " }\\r\\n": 10814, + "\\\"]": 10815, + "valu": 10816, + "is 18": 10817, + "address representing the ": 10818, + ") { ": 10819, + ". Note: ": 10820, + "index of the ": 10821, + "at your ": 10822, + "within ": 10823, + "The default ": 10824, + "the\\n// ": 10825, + "al represent": 10826, + "associ": 10827, + "allows for ": 10828, + "uint amountToken": 10829, + "remaining": 10830, + "bytes memory) {\\n if (success) {\\n return returndata;\\n } else {": 10831, + "string,bool,": 10832, + "slots ": 10833, + "uint,uint,": 10834, + "toHexString(uint256 value, uint256 ": 10835, + "venance": 10836, + "Validation": 10837, + "9a-f": 10838, + "explicitOwnership": 10839, + "obtain": 10840, + "to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId": 10841, + "-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return ": 10842, + "ation with fixed length": 10843, + "====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize": 10844, + "String operations.\\n */\\nlibrary ": 10845, + "[0-9a-f": 10846, + "al representation with fixed length": 10847, + "toHexString(uint256 value, uint256 length": 10848, + "[0-9a-f]{": 10849, + " contract": 10850, + "*/\\n function ": 10851, + "+1": 10852, + "71": 10853, + "E. ": 10854, + "Le": 10855, + "fxs": 10856, + "ension ": 10857, + "toDeleteIndex": 10858, + "uint);\\n function ": 10859, + ", true": 10860, + ", _msgSender(), ": 10861, + " = (1 << ": 10862, + "Map ": 10863, + ";\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://": 10864, + "empty": 10865, + " > 0, errorMessage": 10866, + "Set the ": 10867, + "For an ": 10868, + "\\n // - `burned` to `": 10869, + "\\n // - `startTimestamp` to the timestamp of ": 10870, + "[EIP].\\n *\\n * ": 10871, + "s of the GNU General Public License ": 10872, + "GNU General Public License": 10873, + "VERSION": 10874, + ") internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`": 10875, + "Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section": 10876, + "1;\\n }\\n }\\n return ": 10877, + "WARRANTY; ": 10878, + "gnu.org/licenses/": 10879, + "at your option": 10880, + "Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * ": 10881, + "'s": 10882, + "c / ": 10883, + "confirm": 10884, + "require(_": 10885, + "0.\\n ": 10886, + "totalSupply()": 10887, + "`from`.": 10888, + "_transfer(from, to, amount": 10889, + "grantRole(bytes32 role, address account": 10890, + " > 1; --i": 10891, + "s `amount` of ": 10892, + "tic operation": 10893, + "after the ": 10894, + "value of {decimals} ": 10895, + "secure": 10896, + "override returns (bool) {": 10897, + "ERC165 standard": 10898, + "Interface of the ERC165 standard": 10899, + "& 0xf": 10900, + ");\\n\\n function ": 10901, + "italMedia": 10902, + "for more details.": 10903, + "_transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\"": 10904, + "[value & 0xf": 10905, + "for (uint256 i = 2 * length + 1; i > 1; --i": 10906, + "is 18. To ": 10907, + "Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId": 10908, + "value of {decimals} is 18. To ": 10909, + "(0": 10910, + "(at your option": 10911, + ") any later ": 10912, + "the implied ": 10913, + "the Free Software Foundation": 10914, + "` in ": 10915, + ") {\\n _check": 10916, + "it under the term": 10917, + "as publish": 10918, + "this program": 10919, + "have received a ": 10920, + "lock ": 10921, + "in the hop": 10922, + "+= amount;\\n ": 10923, + "quantity` must be ": 10924, + "but WITHOUT ": 10925, + "e that it will be ": 10926, + "Move the ": 10927, + "Implementers can ": 10928, + "not, see ": 10929, + "without even ": 10930, + "contains": 10931, + " or FITNESS FOR A PARTICULAR PURPOS": 10932, + "inherit ": 10933, + "shares ": 10934, + "Flash": 10935, + "support of contract ": 10936, + "queried by other": 10937, + "e it and/or ": 10938, + ", either version 3 of the ": 10939, + "nftContract": 10940, + "GNU General Public License for more details.": 10941, + "along with this program": 10942, + "totalHashes": 10943, + "you can redistribut": 10944, + "-name-mixedcase": 10945, + "ANY WARRANTY; ": 10946, + "magic ": 10947, + "re: you can redistribut": 10948, + "distributed in the hop": 10949, + "You should have received a ": 10950, + "License, or": 10951, + "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOS": 10952, + "2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/": 10953, + "cooldown": 10954, + "copy of the GNU General Public License": 10955, + "{\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ": 10956, + ". If not, see ": 10957, + "Private function to ": 10958, + "warranty of": 10959, + "free software: you can redistribut": 10960, + "declare support of contract ": 10961, + "aren't ": 10962, + "functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string": 10963, + "-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string": 10964, + "E. See ": 10965, + "s of the GNU General Public License as publish": 10966, + "(at your option) any later ": 10967, + "the implied warranty of": 10968, + "the Free Software Foundation, either version 3 of the ": 10969, + "it under the terms of the GNU General Public License as publish": 10970, + "but WITHOUT ANY WARRANTY; ": 10971, + "e that it will be useful": 10972, + "Implementers can declare support of contract ": 10973, + "without even the implied warranty of": 10974, + "e it and/or modify": 10975, + "along with this program. If not, see ": 10976, + "distributed in the hope that it will be useful": 10977, + "You should have received a copy of the GNU General Public License": 10978, + "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See ": 10979, + "free software: you can redistribute it and/or modify": 10980, + "(at your option) any later version.": 10981, + "the Free Software Foundation, either version 3 of the License, or": 10982, + "it under the terms of the GNU General Public License as published by": 10983, + "but WITHOUT ANY WARRANTY; without even the implied warranty of": 10984, + "Implementers can declare support of contract interfaces": 10985, + "`balance": 10986, + "cp": 10987, + "message": 10988, + "reed": 10989, + "Incorrect": 10990, + "Amounts": 10991, + "{\\n return ": 10992, + ") external only": 10993, + "balance\"": 10994, + "ce\\n // ": 10995, + "operator, bool approved": 10996, + "Data.": 10997, + ".\\n */\\n function _set": 10998, + "constructor (": 10999, + "}.\\n */\\n function isApprovedForAll(address owner, address operator": 11000, + "Updates ": 11001, + "When": 11002, + ";\\n }\\n\\n /// @notice ": 11003, + "sum of all ": 11004, + "functions from the ": 11005, + "required to ": 11006, + "to be transferred": 11007, + "Casted ": 11008, + "authorized": 11009, + "nextInitialized` ": 11010, + ",\\n [": 11011, + "case the ": 11012, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/": 11013, + "5` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless ": 11014, + "rozen": 11015, + "diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/": 11016, + "queried by others (": 11017, + "Implementers can declare support of contract interfaces, which can then ": 11018, + "functions from the ERC20 standard": 11019, + "var": 11020, + ", created ": 11021, + "tokenAddress": 11022, + "uint256 result": 11023, + "\\n function get": 11024, + "nomin": 11025, + "stat": 11026, + "propor": 11027, + "\\r\\n//": 11028, + "happ": 11029, + ") {\\n buffer[i": 11030, + "_approve(address(0), ": 11031, + "constructor() ": 11032, + "may change ": 11033, + "msg.value ": 11034, + "packed = _": 11035, + "Partition": 11036, + "\\\");\\n return string(buffer": 11037, + "registerAnd": 11038, + "see {ERC165": 11039, + "proxy/": 11040, + "\\\", \\\"Q": 11041, + "All two ": 11042, + "\\n\\npragma solidity ^0.8.4": 11043, + "\\\";\\n buffer[1] = \\\"x": 11044, + "{ERC165Checker": 11045, + "2);\\n buffer[0] = \\\"0": 11046, + "implementation, see {ERC165": 11047, + "Collection of functions related to the address type\\n */\\nlibrary Address ": 11048, + "bytes32 indexed role": 11049, + ";\\n }\\n require(value == 0, \\\"Strings: hex length insufficient": 11050, + "bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0": 11051, + "For an implementation, see {ERC165": 11052, + "Interface of the ERC165 standard, as defined in the\\n * ": 11053, + "queried by others ({ERC165Checker": 11054, + "\\\";\\n buffer[1] = \\\"x\\\";\\n ": 11055, + ";\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer": 11056, + "bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n ": 11057, + ">.": 11058, + "Cor": 11059, + "eff": 11060, + ", this ": 11061, + "blog": 11062, + " = \\\"0123456789abcdef": 11063, + ".\\n */\\n function toHexString(uint256 value, uint256 length": 11064, + "pod": 11065, + "\\n// along with this program. If not, see ": 11066, + "\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See ": 11067, + "\\n// (at your option) any later version.": 11068, + "\\n// the Free Software Foundation, either version 3 of the License, or": 11069, + "\\n// it under the terms of the GNU General Public License as published by": 11070, + "Strings.": 11071, + "interface I": 11072, + " > 0) {\\n ": 11073, + "uint amountA": 11074, + "ENTERED": 11075, + ";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` ": 11076, + "receiver ": 11077, + " = _baseURI": 11078, + "format ": 11079, + "Liquidity ": 11080, + "_ownerships[": 11081, + "BBBBBBBBBBBBBBBB": 11082, + "\\n\\n// You should have received a copy of the GNU General Public License": 11083, + "revoked ": 11084, + "average": 11085, + "al representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n ": 11086, + "wiki/": 11087, + "bugs, ": 11088, + ",\\n// but WITHOUT ANY WARRANTY; without even the implied warranty of": 11089, + "bytes16 private constant _": 11090, + ") internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n ": 11091, + "\\n\\n// This program is distributed in the hope that it will be useful": 11092, + "the\\n// GNU General Public License for more details.": 11093, + "al representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length": 11094, + "free software: you can redistribute it and/or modify\\n// it under the terms of the GNU General Public License as published by": 11095, + "Implementers can declare support of contract interfaces, which can then be\\n * ": 11096, + "\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\n// GNU General Public License for more details.": 11097, + "\\n// (at your option) any later version.\\n\\n// This program is distributed in the hope that it will be useful": 11098, + "\\n// the Free Software Foundation, either version 3 of the License, or\\n// (at your option) any later version.\\n\\n// This program is distributed in the hope that it will be useful": 11099, + ";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString": 11100, + "\\n\\n// You should have received a copy of the GNU General Public License\\n// along with this program. If not, see ": 11101, + ",\\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\n// GNU General Public License for more details.": 11102, + "free software: you can redistribute it and/or modify\\n// it under the terms of the GNU General Public License as published by\\n// the Free Software Foundation, either version 3 of the License, or\\n// (at your option) any later version.\\n\\n// This program is distributed in the hope that it will be useful": 11103, + ",\\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\n// GNU General Public License for more details.\\n\\n// You should have received a copy of the GNU General Public License\\n// along with this program. If not, see ": 11104, + "free software: you can redistribute it and/or modify\\n// it under the terms of the GNU General Public License as published by\\n// the Free Software Foundation, either version 3 of the License, or\\n// (at your option) any later version.\\n\\n// This program is distributed in the hope that it will be useful,\\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\n// GNU General Public License for more details.\\n\\n// You should have received a copy of the GNU General Public License\\n// along with this program. If not, see ": 11105, + "_take": 11106, + "_excluded": 11107, + "all the ": 11108, + "callable ": 11109, + "project ": 11110, + "resulting ": 11111, + "string memory name": 11112, + "\\n * @dev See ": 11113, + "Strings {\\n ": 11114, + ");\\r\\n ": 11115, + "collateralToken": 11116, + "contract is paused": 11117, + ",\\r\\n \\\"": 11118, + " <= a": 11119, + "https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * ": 11120, + "\"lib/openzeppelin-contracts/contracts/": 11121, + "added or ": 11122, + "When `from` and `to` are both non-zero, `from`'s ": 11123, + "JSON-R": 11124, + "caller is not owner nor approved": 11125, + "burned by `from`.": 11126, + "}).\\n *\\n * For an implementation, see {ERC165": 11127, + "queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165": 11128, + "al representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n ": 11129, + "Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165": 11130, + "Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface ": 11131, + "LOO": 11132, + "XSD": 11133, + "s;\\n ": 11134, + "\\\"\\r\\n ": 11135, + "\\\" (": 11136, + "tokens to ": 11137, + "tokensOfOwner": 11138, + ";\\n }\\n ": 11139, + "\\r\\n * @param _": 11140, + "mission": 11141, + "Nonce": 11142, + "usted": 11143, + "reverting on\\n * overflow.\\n *\\n * ": 11144, + "ABI": 11145, + ");\\n }\\n\\n function ": 11146, + "processProof": 11147, + "_status = _": 11148, + "];\\n value >>= 4": 11149, + "uint256 c = a + b": 11150, + "optional metadata functions from the ERC20 standard": 11151, + "significant ": 11152, + "(Counter storage counter) internal {\\n ": 11153, + "\"// SPDX-License-Identifier: GPL-3.0-or-later\\n// ": 11154, + ";\\n\\n mapping(address => mapping(address => uint256": 11155, + " from int256, reverting on\\n * overflow (when the input is less than smallest int": 11156, + "\\\"],\\n [": 11157, + "[value & 0xf];\\n value >>= 4": 11158, + "for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i": 11159, + "Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * ": 11160, + "[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer": 11161, + "Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface ": 11162, + ".\\n // - `startTimestamp` to the timestamp of ": 11163, + "= subtractedValue, \\\"ERC20: decreased allowance below zero": 11188, + "MY_ROLE": 11189, + "gnu.org/licenses/>.": 11190, + "added or removed": 11191, + ".": 11192, + "CK": 11193, + "Given": 11194, + "ier": 11195, + "tog": 11196, + "isexemptfrom": 11197, + "amount\\r\\n ": 11198, + "\\r\\n *\\r\\n * ": 11199, + "Token is ": 11200, + "There ": 11201, + "getReserves": 11202, + "_AM": 11203, + "hashes[": 11204, + "\\n */\\n function set": 11205, + "0 && ": 11206, + "result;\\n }\\n\\n /**\\n * @dev ": 11207, + ");\\n }\\n\\n function set": 11208, + "ApprovalForAll(address indexed owner, address indexed ": 11209, + "this function uses ": 11210, + "access/AccessControl": 11211, + "bytes(baseURI": 11212, + "(address to, uint256 quantity": 11213, + "uses an ": 11214, + ");\\n }\\n }\\n }\\n\\n /**\\n * @dev ": 11215, + "somehow ": 11216, + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a ": 11217, + "child": 11218, + "opcode (which leaves remaining gas untouched) while Solidity": 11219, + ",\\r\\n address to,\\r\\n uint256 ": 11220, + "Item": 11221, + "/` operator. Note: ": 11222, + "amount\\n ) external returns (bool": 11223, + "quantity` must be greater than 0": 11224, + "free software: you can redistribute it and/or modify\\n// it under the terms of the GNU General Public License as published by\\n// the Free Software Foundation, either version 3 of the License, or\\n// (at your option) any later version.\\n\\n// This program is distributed in the hope that it will be useful,\\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\n// GNU General Public License for more details.\\n\\n// You should have received a copy of the GNU General Public License\\n// along with this program. If not, see .": 11225, + "al representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i": 11226, + "revert` opcode (which leaves remaining gas untouched) while Solidity": 11227, + "ApprovalForAll(address indexed owner, address indexed operator, bool approved": 11228, + "/` operator. Note: this function uses ": 11229, + "Migr": 11230, + "Tri": 11231, + "nip": 11232, + "s in the ": 11233, + "imil": 11234, + "sure the ": 11235, + "ip ": 11236, + "in case the ": 11237, + " to `": 11238, + " of its ": 11239, + ";\\n\\n ": 11240, + "numTokens": 11241, + "Roles": 11242, + "new uint256": 11243, + "aps": 11244, + "apter": 11245, + "\"@openzeppelin/contracts/token/ERC20/IERC20.sol\"": 11246, + "disable ": 11247, + "191": 11248, + " from the ": 11249, + "-= 1;\\n ": 11250, + " of two unsigned integers, reverting on\\n * overflow.\\n *\\n * ": 11251, + "Exceeds": 11252, + "Down(": 11253, + "Entries": 11254, + "_isApprovedOrOwner(_msgSender(), ": 11255, + "lower 160 bits, ": 11256, + "mstore8(": 11257, + "uint256 accountBalance = _balances[account];\\n require(": 11258, + "upper bits somehow ": 11259, + "s `amount` of tokens from ": 11260, + "aren't clean": 11261, + "in case the upper bits somehow ": 11262, + "lower 160 bits, in case the upper bits somehow ": 11263, + "lower 160 bits, in case the upper bits somehow aren't clean": 11264, + "Meta": 11265, + "SN": 11266, + "lif": 11267, + "s of a ": 11268, + ", bytes calldata ": 11269, + "ord ": 11270, + "ERC777": 11271, + "\\n * {": 11272, + "tokenId, _data": 11273, + "aily": 11274, + "with the\\n * ": 11275, + ";\\n\\n function ": 11276, + "Chiru": 11277, + "(msg.sender, _": 11278, + ";\\r\\n uint256 public ": 11279, + "access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev ": 11280, + "manage the ": 11281, + "] = _packOwnershipData": 11282, + "token/ERC20/ERC20.sol\"": 11283, + "otherwise ": 11284, + "_allowances[sender": 11285, + "granted `role`, emits a {RoleRevoked": 11286, + "extraData = ": 11287, + "leavesLen ": 11288, + "dynam": 11289, + " been granted `role`, emits a {RoleRevoked": 11290, + "\\n * - `from` and `to` are never both zero.\\n */\\n function _": 11291, + " of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function try": 11292, + "Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\"": 11293, + "diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n ": 11294, + "burned by `from`.\\n * - `from` and `to` are never both zero.\\n */\\n function _": 11295, + "Chiru L": 11296, + "access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _transferOwnership(_msgSender()": 11297, + ".°": 11298, + ".toString": 11299, + "Bps": 11300, + "IOperatorFilterRegistry": 11301, + "den ": 11302, + "{length": 11303, + "°.": 11304, + "rebuil": 11305, + "ERCENT": 11306, + "index` must be ": 11307, + "proxy ": 11308, + "\\r\\n\\t\\t": 11309, + "part": 11310, + "burned = ": 11311, + "when more ": 11312, + "nonc": 11313, + ") {\\n ": 11314, + "ATER": 11315, + "was not\\n * ": 11316, + "array, and it ": 11317, + "eriting ": 11318, + "initialized": 11319, + "Note that there are no ": 11320, + "Manual": 11321, + "ordering of ": 11322, + "Subscri": 11323, + "Moves `amount` of tokens from ": 11324, + "0;\\n unchecked {\\n ": 11325, + ");\\n }\\n }\\n }\\n}\\n\"": 11326, + "pragma solidity 0.8.17": 11327, + "position `index` ": 11328, + "avoid-": 11329, + "s on the ordering of ": 11330, + "guarantees on the ordering of ": 11331, + "stored at position `index` ": 11332, + "OWNER": 11333, + "https://github.com/OpenZeppelin/openzeppelin-contracts/": 11334, + "strictly less than {length": 11335, + "may change when more ": 11336, + "index` must be strictly less than {length": 11337, + "was not\\n * already ": 11338, + "array, and it may change when more ": 11339, + "Note that there are no guarantees on the ordering of ": 11340, + "1a": 11341, + "216": 11342, + "Cr": 11343, + "Pass": 11344, + "ign": 11345, + "isOperator": 11346, + "ing to the ": 11347, + " = 5": 11348, + "operator-f": 11349, + "when a ": 11350, + "!= 0) {\\n ": 11351, + "MaxLength": 11352, + "Strategy": 11353, + ".\\n unchecked {\\n // ": 11354, + "slot's ": 11355, + "assembly {\\n // ": 11356, + "initializer ": 11357, + "ilter-": 11358, + "\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./": 11359, + "\\\");\\n ": 11360, + "save ": 11361, + "free memory ": 11362, + ".sol';\\nimport '@openzeppelin/contracts/": 11363, + "based on ": 11364, + "(address from, address to, uint256 tokenId": 11365, + "decimals places of the token.\\n */\\n function ": 11366, + "The default value of {decimals} is 18. To ": 11367, + "String operations.\\n */\\nlibrary Strings {\\n ": 11368, + "JSON-RPC ": 11369, + "_isApprovedOrOwner(_msgSender(), tokenId": 11370, + "operator-filter-": 11371, + "\\x": 11372, + "nd ": 11373, + "son ": 11374, + "TokenAmount": 11375, + "\\n * (": 11376, + "32;\\n result += ": 11377, + "recipient` cannot be the zero address": 11378, + "the zero address.\\n */\\n error ": 11379, + "16;\\n result += ": 11380, + "operatorData": 11381, + "64;\\n result += ": 11382, + "leav": 11383, + ".\\n assembly {\\n ": 11384, + "TxLimit": 11385, + ".\\n *\\n * _Available since v4.1._": 11386, + "trySub": 11387, + "tryMod": 11388, + "(value);\\n return result + (rounding == Rounding.Up && ": 11389, + "(uint256 value) internal pure returns (uint256) {\\n uint256 result = ": 11390, + "(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = ": 11391, + "result += 1;\\n }\\n }\\n return ": 11392, + "176": 11393, + ");\\n }\\n }\\n\\n /**\\n * @dev Return the log in base ": 11394, + "inheritdoc": 11395, + "\\n\\t *\\n\\t * ": 11396, + "Sync": 11397, + "Creator: ": 11398, + "\\n */\\n event ": 11399, + "`nonReentrant` function ": 11400, + "name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the ": 11401, + "_d18": 11402, + "circum": 11403, + ") external view returns (uint256 balance": 11404, + "deprecated ": 11405, + "0,\\n 0,\\n ": 11406, + "result;\\n }\\n\\n /**\\n * @dev Return the log in base ": 11407, + "0;\\n unchecked {\\n if (value ": 11408, + "(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value ": 11409, + "result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base ": 11410, + "(uint8(": 11411, + "/ ": 11412, + "], ": 11413, + "eloper": 11414, + "OwnerQueryForNonexistentToken": 11415, + "che": 11416, + "(address recovered": 11417, + "memory for the ": 11418, + "name, ": 11419, + " _nextExtraData": 11420, + "URIQueryForNonexistentToken": 11421, + "since it ": 11422, + "Out(": 11423, + "██║": 11424, + "disabl": 11425, + "\\n *\\n * NOTE: This ": 11426, + " ": 11427, + "\\n * @author ": 11428, + "TokenOwnership` ": 11429, + "Params ": 11430, + "_INTER": 11431, + "` to the lower 160 bits, in case the upper bits somehow aren't clean": 11432, + " {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the ": 11433, + ", IERC20Metadata {\\n ": 11434, + "overridden ": 11435, + "(uint256 tokenId) external view returns (address owner": 11436, + "symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the ": 11437, + "TreasuryFee": 11438, + "This program is free software: you can redistribute it and/or modify\\n// it under the terms of the GNU General Public License as published by\\n// the Free Software Foundation, either version 3 of the License, or\\n// (at your option) any later version.\\n\\n// This program is distributed in the hope that it will be useful,\\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\n// GNU General Public License for more details.\\n\\n// You should have received a copy of the GNU General Public License\\n// along with this program. If not, see .": 11439, + ") return (false, 0);\\n return (": 11440, + "as part of ": 11441, + " of two unsigned integers, reverting with custom message ": 11442, + "mload(add(signature, 0x": 11443, + "concatenation": 11444, + "decimals places of the token.\\n */\\n function decimals() external view returns (uint8": 11445, + "symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8": 11446, + ") return (false, 0);\\n return (true, ": 11447, + "(a + b": 11448, + "120": 11449, + "CAN": 11450, + "IG": 11451, + "Mut": 11452, + "s.sol\"": 11453, + "tre": 11454, + "s < ": 11455, + "acces": 11456, + "bool)": 11457, + " = \\\"": 11458, + "minim": 11459, + "payer": 11460, + "address,address": 11461, + "level-call": 11462, + ") / _": 11463, + "recover}.\\n */\\n function ": 11464, + "low-level-call": 11465, + "(from, to, tokenId, 1": 11466, + "\\n * @param tokenId uint256 ID of the token": 11467, + "s `tokenId": 11468, + "respon": 11469, + "compute the ": 11470, + "global ": 11471, + ".\\n *\\n * See {recover}.\\n */\\n function ": 11472, + "benefit ": 11473, + "✓✓✓✓": 11474, + "allocating ": 11475, + "`\\n * opcode (which leaves remaining gas untouched) while Solidity uses ": 11476, + ", bool _approved": 11477, + "vocation": 11478, + "%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses ": 11479, + "ERC-721 Non-Fungible Token Standard": 11480, + "helpers/": 11481, + "\"// SPDX-License-Identifier: GPL-3.0-or-later\\n// This program is free software: you can redistribute it and/or modify\\n// it under the terms of the GNU General Public License as published by\\n// the Free Software Foundation, either version 3 of the License, or\\n// (at your option) any later version.\\n\\n// This program is distributed in the hope that it will be useful,\\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\n// GNU General Public License for more details.\\n\\n// You should have received a copy of the GNU General Public License\\n// along with this program. If not, see .": 11482, + "Chiru Labs": 11483, + " {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8": 11484, + "%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * ": 11485, + " \\u003c": 11486, + "CTION": 11487, + "Dig": 11488, + "_enabled": 11489, + "ating": 11490, + "s\\n * ": 11491, + "yet": 11492, + "s use {": 11493, + "unnecessari": 11494, + "ly. For ": 11495, + "This\\n * ": 11496, + ") {\\n /// @solidity memory-safe-assembly\\n assembly {\\n ": 11497, + ") internal pure ": 11498, + "0000000": 11499, + "utdown": 11500, + "Required ": 11501, + "Struc": 11502, + "operate ": 11503, + "message unnecessari": 11504, + "Emitted when `tokenId` token is ": 11505, + "custom revert reason": 11506, + "Wrappers ": 11507, + "amount);\\n emit Transfer": 11508, + "seriesSum": 11509, + "CAUTION: This function is ": 11510, + "requires allocating ": 11511, + "Subtraction cannot overflow.\\n */\\n function ": 11512, + "because it requires allocating ": 11513, + ";\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n ": 11514, + "inherit from ": 11515, + "Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev ": 11516, + "inheritdoc ": 11517, + "Creator: Chiru Labs": 11518, + "deprecated because it requires allocating ": 11519, + "memory for the error": 11520, + "ly. For custom revert reason": 11521, + "message unnecessarily. For custom revert reason": 11522, + "CAUTION: This function is deprecated because it requires allocating ": 11523, + "message unnecessarily. For custom revert reasons use {": 11524, + "CAUTION: This function is deprecated because it requires allocating memory for the error": 11525, + "Farm": 11526, + "VX": 11527, + "_revert": 11528, + "a9": 11529, + "toggle": 11530, + "\\n * ": 11531, + "a token ": 11532, + "a given ": 11533, + "Transfer` ": 11534, + "), mload(": 11535, + "\\r\\n\\t": 11536, + "sender ": 11537, + "will receive the ": 11538, + " <<": 11539, + "approved, uint256 ": 11540, + "FFFFFF": 11541, + "https://eips.ethereum.org/EIPS/eip-2612": 11542, + "FFFFFFFFFFFFFF": 11543, + "initialized ": 11544, + "on\\n * division by zero. The result is rounded towards ": 11545, + "Strings.sol\"": 11546, + "values inside ": 11547, + "values are added or removed": 11548, + "Wallet = ": 11549, + "Removes a value ": 11550, + "ardiz": 11551, + "remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * ": 11552, + "magic value": 11553, + "\\n * @dev See https://eips.ethereum.org/EIPS/eip-721": 11554, + "array, and it may change when more values are added or removed": 11555, + "Note that there are no guarantees on the ordering of values inside ": 11556, + "ERC-721 Non-Fungible Token Standard, ": 11557, + "Subtraction cannot overflow.\\n */\\n function sub": 11558, + "Removes a value from a ": 11559, + "'re ": 11560, + "-of": 11561, + "64.": 11562, + "{permit": 11563, + "another": 11564, + "256 bit ": 11565, + "exper": 11566, + "ancake": 11567, + "to avoid ": 11568, + "address spender": 11569, + "a role": 11570, + "of two numbers": 11571, + "208": 11572, + "return the ": 11573, + "pause ": 11574, + "ting the ": 11575, + "` to manage the ": 11576, + "ativel": 11577, + "s for uint256": 11578, + "packed & _BITMASK": 11579, + "`) `operator` to ": 11580, + "produces ": 11581, + "common": 11582, + "PPPP": 11583, + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n ": 11584, + "\\n */\\n function ": 11585, + "manage all of its ": 11586, + "`approved` to manage the ": 11587, + "See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(": 11588, + "set._indexes[value": 11589, + "IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8": 11590, + "associated ": 11591, + "uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn ": 11592, + "] = _packOwnershipData(\\n ": 11593, + "avoid-low-level-call": 11594, + "of two numbers.\\n */\\n function ": 11595, + "`) `operator` to manage all of its ": 11596, + "`approved` to manage the `tokenId` token": 11597, + "63": 11598, + "Nomin": 11599, + "_writeCheckpoint": 11600, + "simp": 11601, + "to its ": 11602, + "), and ": 11603, + "recipient, amount": 11604, + "if (_": 11605, + "balances[": 11606, + "swapAndLiquify": 11607, + ";\\n }\\n\\n /**\\n * @dev Add ": 11608, + "ids": 11609, + "string memory baseURI": 11610, + "empty ": 11611, + "one signed ": 11612, + "transferred from `from` to `to`": 11613, + "() public view virtual override returns (uint8) {\\n return 18": 11614, + "method as part of ": 11615, + "100000": 11616, + "fee recipient": 11617, + "status": 11618, + "ensure ": 11619, + "parameter ": 11620, + "(uint256 tokenId) external view returns (address operator": 11621, + "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF": 11622, + "_LIQUIDITY": 11623, + "Voting": 11624, + "RecoverError error) = ": 11625, + "RUCT": 11626, + "String operations.\\n */\\nlibrary Strings {\\n bytes16 private constant _": 11627, + "JSON-RPC method as part of ": 11628, + "circumvent": 11629, + "(address recovered, ": 11630, + "-of-": 11631, + "{permit} ": 11632, + "JSON-RPC method as part of EIP-": 11633, + "\"TOKEN": 11634, + "));\\n }\\n\\n function ": 11635, + ".\\n */\\n function ": 11636, + "85": 11637, + "<< _": 11638, + "Star": 11639, + "_delegate": 11640, + "pend": 11641, + "rend": 11642, + "tribu": 11643, + "seed": 11644, + "2098": 11645, + "by mak": 11646, + "ckpt": 11647, + "\\r\\n // ": 11648, + ", address to, ": 11649, + "Receive": 11650, + "pre-": 11651, + "data structu": 11652, + "uint256) {\\n return _": 11653, + "baseURI, ": 11654, + "_setOwner": 11655, + "\\n ) external payable": 11656, + "where the ": 11657, + "Alread": 11658, + "\\\"\\n );\\n\\n ": 11659, + "Fee + ": 11660, + "_packedOwnerships": 11661, + "https://github.com/ethereum/solidity": 11662, + "list of ": 11663, + "() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol": 11664, + "interest": 11665, + " or\\n * greater than largest int": 11666, + "mapping(address => uint256) private _balances;\\n\\n mapping(address => mapping(address => uint256": 11667, + "conventional ": 11668, + "account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance": 11669, + "\\r\\n /**\\r\\n * ": 11670, + "Average": 11671, + "Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\"": 11672, + "https://github.com/ethereum/solidity/": 11673, + "() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol": 11674, + " {\\n function ": 11675, + "raction": 11676, + "account.\\n *\\n * ": 11677, + "loan": 11678, + "checked ": 11679, + "] : ": 11680, + "signed by the ": 11681, + "ilit": 11682, + "] = approved": 11683, + "to, tokenId": 11684, + "must be owned by `from": 11685, + "Update ": 11686, + "Enumerable ": 11687, + "extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721": 11688, + "we check ": 11689, + ");\\n\\n /**\\n * @dev Returns the number of tokens in ": 11690, + ");\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf": 11691, + "write ": 11692, + "Holders": 11693, + "Copy ": 11694, + "DefaultOperatorFilterer": 11695, + "assets.\\n */\\n event ": 11696, + "▒▒▒▒": 11697, + "Staking": 11698, + "amount exceeds balance\\\");\\n unchecked {\\n _balances[account] = accountBalance - amount": 11699, + "tryRecover(hash, v, r, s": 11700, + "governance": 11701, + ") external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved": 11702, + ";\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol": 11703, + "All two of these values are immutable: they can only be set once during\\n * construction": 11704, + "optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._": 11705, + "bytes(baseURI).length": 11706, + "(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to": 11707, + "produces hash ": 11708, + "`) `operator` to manage all of its assets.\\n */\\n event ": 11709, + "account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf": 11710, + "optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface ": 11711, + "account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to": 11712, + "\"Trading ": 11713, + ")), ": 11714, + ";\\r\\n ": 11715, + "ili": 11716, + "phase": 11717, + "yet ": 11718, + "s guidelines: functions ": 11719, + "uint256[] ": 11720, + "ed as ": 11721, + "er = ": 11722, + "signator": 11723, + ", \\\"!": 11724, + ") internal pure returns (address, ": 11725, + "aug": 11726, + "scale": 11727, + "OpenZeppelin Contracts guidelines: functions ": 11728, + "marketingFeeReceiver": 11729, + "`]\\n * ": 11730, + "deployment": 11731, + "_NAM": 11732, + "maxWalletAmount": 11733, + "ERC721 token ": 11734, + "automatedMarketMakerPairs[": 11735, + "} and {revokeRole": 11736, + "functionDelegateCall(target, data, \\\"Address: low-level ": 11737, + "\\n */\\ninterface IERC721": 11738, + "(uint256 tokenId) external view returns (string memory": 11739, + "grantRole} and {revokeRole": 11740, + ".\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables ": 11741, + ".\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 ": 11742, + "(account, address(0), amount);\\n\\n _afterTokenTransfer": 11743, + ";\\n // Overflow not possible: ": 11744, + "indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or ": 11745, + "was\\n * ": 11746, + "Insufficient ": 11747, + "instead returning `false` on failure. This behavior is nonethel": 11748, + "\\n //////////////////////////////////////////////////////////////*/\\n\\n ": 11749, + "and does not conflict with the expectations of ERC20": 11750, + "throwError(error": 11751, + ")\\\", p0));\\n\\t}\\n\\n\\tfunction logBytes": 11752, + "ignore": 11753, + ";\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * ": 11754, + "provides an ": 11755, + "Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ": 11756, + "together ": 11757, + "ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ": 11758, + "Emitted when `tokenId` token is transferred from `from` to `to`": 11759, + "`approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 ": 11760, + "(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev ": 11761, + "(address recovered, RecoverError error) = ": 11762, + "conventional and does not conflict with the expectations of ERC20": 11763, + ") external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev ": 11764, + "`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ": 11765, + ") internal pure returns (address, RecoverError": 11766, + "OpenZeppelin Contracts guidelines: functions revert": 11767, + "functionDelegateCall(target, data, \\\"Address: low-level delegate ": 11768, + ".\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 ": 11769, + "instead returning `false` on failure. This behavior is nonetheless": 11770, + ".\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or ": 11771, + "(see {": 11772, + "Pur": 11773, + "could ": 11774, + "x * ": 11775, + "publicSale": 11776, + "bytecode": 11777, + "opy": 11778, + "value stored at position `index` ": 11779, + "== 1": 11780, + ";\\n\\n constructor(": 11781, + ").\\r\\n *\\r\\n * ": 11782, + "Roles are ": 11783, + "delegation": 11784, + "resultPtr": 11785, + "Set {\\n ": 11786, + "_taxFeeOnSell": 11787, + "ST ": 11788, + "emit Transfer(address(0), account, amount);\\n\\n ": 11789, + "addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n ": 11790, + "mload(0x": 11791, + "to a set. O(1).\\n *\\n * Returns true if the value was ": 11792, + " not been already ": 11793, + "Returns true if the value is ": 11794, + "interfaces/contracts/": 11795, + "cases ": 11796, + "grantRole} ": 11797, + ".call{value: amount": 11798, + "granted `role`, emits a {RoleGranted": 11799, + "set, that is if it was not\\n * already ": 11800, + "set, that is if it was\\n * ": 11801, + "set. O(1).\\n *\\n * Returns true if the value was removed from the ": 11802, + "added to the set, that is if it was not\\n * already ": 11803, + "a value to a set. O(1).\\n *\\n * Returns true if the value was ": 11804, + "Counters.Counter": 11805, + ".\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n ": 11806, + "written ": 11807, + "/**\\r\\n * @dev ": 11808, + "imilar": 11809, + "Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the ": 11810, + ";\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was ": 11811, + "optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8": 11812, + "Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or ": 11813, + "emit Transfer(address(0), account, amount);\\n\\n _afterTokenTransfer": 11814, + " not been already granted `role`, emits a {RoleGranted": 11815, + "Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * ": 11816, + ";\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already ": 11817, + "45": 11818, + "IVault": 11819, + "Lz": 11820, + "_VERSION": 11821, + ", a ": 11822, + "acter": 11823, + "acopy": 11824, + "owner != address(0), \\\"": 11825, + "\\n * ": 11826, + "datacopy": 11827, + ") {\\n uint256 ": 11828, + "Address = ": 11829, + "Address.sol\"": 11830, + "The maximum ": 11831, + "\\r\\n {\\r\\n ": 11832, + "collect": 11833, + ") public view virtual override returns (bool) {\\n return _": 11834, + "_tokenURI": 11835, + "Registry ": 11836, + "BPT ": 11837, + "s\\n mapping(address => ": 11838, + "For example:\\n *\\n * ": 11839, + "`.\\n *\\n * This internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer": 11840, + "-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return ": 11841, + "nft contract": 11842, + "_approve(_msgSender(), spender, _allowances[_msgSender()][spender": 11843, + "blockTimestampLast": 11844, + "pull/": 11845, + "(\\n address operator,\\n address from": 11846, + "nonces[": 11847, + "Creator: Chiru Labs\\n\\npragma solidity ^0.8.4": 11848, + ",string ": 11849, + "Fir": 11850, + "If": 11851, + "Ori": 11852, + "fc": 11853, + "p256": 11854, + "}\\r\\n ": 11855, + "es\\n * ": 11856, + "a set of ": 11857, + "value}": 11858, + "Controller": 11859, + "min(": 11860, + "Router ": 11861, + ") internal pure returns (address) {\\n ": 11862, + "Time = ": 11863, + "transfer caller is not owner nor approved": 11864, + "result * ": 11865, + "}.\\r\\n */\\r\\n function ": 11866, + "read ": 11867, + "ERC721A: ": 11868, + "verifyingContract": 11869, + " bits\\\"": 11870, + "approved address": 11871, + "BasePool": 11872, + "into a ": 11873, + "price0": 11874, + "price1": 11875, + "BITPOS_AUX": 11876, + "Factory ": 11877, + "(address owner, address spender, uint256 amount": 11878, + "math ": 11879, + "has been transferred to `to`.\\n * - when `from` is zero, `amount` ": 11880, + "secp256": 11881, + "support for ": 11882, + "queried ": 11883, + ") internal view returns (bool) {\\n return _": 11884, + "burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer": 11885, + "set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address": 11886, + "tokens have been burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer": 11887, + "Compute the ": 11888, + "Library.": 11889, + ")) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * ": 11890, + "Swapped": 11891, + "(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn ": 11892, + "Release": 11893, + "_AMOUNT": 11894, + "\"TOKEN: ": 11895, + "has been transferred to `to`.\\n * - when `from` is zero, `amount` tokens have been ": 11896, + "secp256k": 11897, + "_contract": 11898, + "{tokenURI": 11899, + "iteration": 11900, + "cost ": 11901, + "a valid ": 11902, + "ing and ": 11903, + "used by ": 11904, + "bytes32) {\\n return _": 11905, + ");\\n\\n // =============================================================\\n // ": 11906, + "Mint ": 11907, + "override {": 11908, + "************": 11909, + "Strings for uint256": 11910, + "unchecked {\\n return ": 11911, + "approvalCheck": 11912, + "generated ": 11913, + ") / b": 11914, + "int256 constant ": 11915, + "Alloc": 11916, + "optimization": 11917, + "MaxWalletAmount": 11918, + "' value": 11919, + "build": 11920, + "Max wallet ": 11921, + "the calling account.\\n *\\n * ": 11922, + "Scal": 11923, + ".sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, ": 11924, + "`account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted": 11925, + "address data.\\n uint256 private constant _": 11926, + "a == b": 11927, + "ieve ": 11928, + ");\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address": 11929, + "for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved": 11930, + "functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string": 11931, + "`account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event": 11932, + ")\\n * ": 11933, + ",\\r\\n ": 11934, + "1, ": 11935, + "75": 11936, + "aa": 11937, + "ho": 11938, + "ros": 11939, + "ated in ": 11940, + "amount to be transferred": 11941, + ".slot ": 11942, + "MintAmount": 11943, + "PerShare": 11944, + ".\\n * @param _": 11945, + "numberMinted ": 11946, + "variables ": 11947, + "total supply ": 11948, + "== 0) revert Mint": 11949, + "sqrt(": 11950, + "know ": 11951, + ",uint256 nonce": 11952, + "}\\n }\\n\\n // =============================================================\\n // ": 11953, + "TokenOwnership memory": 11954, + "\\n *\\n * ": 11955, + "handle": 11956, + "/*//////////////////////////////////////////////////////////////\\n ": 11957, + "votingPower": 11958, + "Ethereum Signed Message:": 11959, + "information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18": 11960, + "Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event": 11961, + ";\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5": 11962, + "-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string": 11963, + "-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall": 11964, + ") * ": 11965, + "1c": 11966, + ") of ": 11967, + "see": 11968, + "TokenGated": 11969, + "ERC20(\\\"": 11970, + "ification": 11971, + "value, \\\"SafeCast: value doesn't fit in ": 11972, + "charg": 11973, + "add(_": 11974, + "s.\\n ": 11975, + "== value, \\\"SafeCast: value doesn't fit in ": 11976, + "ApprovalQueryForNonexistentToken": 11977, + "ApprovalCallerNotOwnerNorApproved": 11978, + "Allowance = ": 11979, + ");\\n return recovered": 11980, + ";\\n }\\n\\n struct ": 11981, + "Delegation": 11982, + ");\\n _throwError(error": 11983, + "flation": 11984, + "STRUCT": 11985, + "them.\\n *\\n * ": 11986, + " {\\n /**\\n * @dev Emitted when ": 11987, + "(account, amount": 11988, + "downcasted = ": 11989, + "Multipl": 11990, + "downcasted == value, \\\"SafeCast: value doesn't fit in ": 11991, + "ratio ": 11992, + "Price(": 11993, + "index out of bound": 11994, + "otherwise": 11995, + "After ": 11996, + "TransferToZeroAddress": 11997, + "_setupDecimals": 11998, + "Implementation of the {IERC165": 11999, + "() external pure returns (address": 12000, + "address that will receive the ": 12001, + "TransferFromIncorrect": 12002, + "redemption": 12003, + ");\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves `amount` of tokens from ": 12004, + "off-chain ": 12005, + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b": 12006, + "from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(": 12007, + "a role's ": 12008, + "extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721": 12009, + "All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_": 12010, + ") internal pure returns (address) {\\n (address recovered, RecoverError error) = ": 12011, + ");\\n return recovered;\\n }\\n\\n /**\\n * @dev ": 12012, + ");\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev ": 12013, + " by ": 12014, + " || ": 12015, + "-` operator.\\n *\\n * Requirements:\\n *\\n * - ": 12016, + "3e": 12017, + "_reward": 12018, + "_implementation": 12019, + " - ": 12020, + "tier": 12021, + "iment": 12022, + "ull": 12023, + "overload": 12024, + ". Al": 12025, + "newAdmin": 12026, + "IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the ": 12027, + ", pre": 12028, + "ature ": 12029, + " is the ": 12030, + "!= type(uint256).max": 12031, + "uniswapV2Router.": 12032, + "&&\\n ": 12033, + "IERC165.sol\\\";\\n\\n/**\\n * @dev ": 12034, + "digit": 12035, + "(value))": 12036, + "ADDRESS": 12037, + "token/ERC721/ERC721": 12038, + "\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../": 12039, + "upgradeTo": 12040, + "automatically ": 12041, + "_newFee": 12042, + "Symbol": 12043, + "NSFER": 12044, + "child ": 12045, + "} interface.\\n *\\n * Contract": 12046, + ".call{value: value}": 12047, + ",\\n bytes calldata data\\n ) external returns (": 12048, + "Splitter": 12049, + "until ": 12050, + "- subtractedValue);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves `amount` of tokens from ": 12051, + " of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `": 12052, + "one signed with the\\n * ": 12053, + "`]\\n * JSON-RPC method as part of EIP-": 12054, + "(account, address(0), amount);\\n\\n _afterTokenTransfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve": 12055, + "Purch": 12056, + ",uint256 nonce,uint256 ": 12057, + "from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(to != address(0), \\\"ERC20: ": 12058, + "(uint amountOut": 12059, + "29": 12060, + "GSN": 12061, + "_balance": 12062, + "_supply": 12063, + "listing": 12064, + ") | ": 12065, + "tokenApproval": 12066, + "return interfaceId == type(": 12067, + "its subscription": 12068, + "BalanceQueryForZeroAddress": 12069, + ",\\n uint256 deadline": 12070, + "(_tokenId": 12071, + ";\\n }\\n\\n /**\\n * @dev Returns the subtraction": 12072, + "}\\n\\n return ": 12073, + "######": 12074, + "(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes memory _data\\n ": 12075, + "whenPaused": 12076, + "bytes4 retval": 12077, + "managed by ": 12078, + "utils/introspection/IERC165.sol\"": 12079, + "    ": 12080, + "onlyAllowedOperatorApproval": 12081, + ">= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n unchecked {\\n ": 12082, + ")\\n public\\n view\\n virtual\\n override": 12083, + "(bool success, ) = recipient.call{value: amount": 12084, + ".\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function ": 12085, + "experiment": 12086, + "Implementation of the {IERC165} interface.\\n *\\n * Contract": 12087, + "-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub": 12088, + " as ": 12089, + ")`": 12090, + "SY": 12091, + "], \\\"": 12092, + "accumul": 12093, + "returns (bool) {\\r\\n ": 12094, + "pack ": 12095, + "reserveB": 12096, + "198": 12097, + "\\n *\\n * @dev ": 12098, + "\\n //\\n // ": 12099, + "Divide ": 12100, + "ordin": 12101, + ".\\n */\\nabstract contract ERC165": 12102, + "Bots": 12103, + "means ": 12104, + ") {\\n return ": 12105, + "minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer": 12106, + "2,\\n 2,\\n 2,\\n 2,\\n ": 12107, + "any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * has been transferred to `to`.\\n * - when `from` is zero, `amount` tokens have been ": 12108, + "er to use ": 12109, + "Underflow": 12110, + ") public payable virtual ": 12111, + "string(abi.encodePacked(baseURI, ": 12112, + "Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer": 12113, + ",\\n address[] calldata path,\\n address to,\\n uint deadline": 12114, + "LOOKS": 12115, + "All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5": 12116, + "any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * has been transferred to `to`.\\n * - when `from` is zero, `amount` tokens have been minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer": 12117, + "(role": 12118, + "-st": 12119, + "1f": 12120, + "A4": 12121, + "Date": 12122, + "`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be ": 12123, + "pc": 12124, + "enable ": 12125, + "// F": 12126, + "spac": 12127, + "aid": 12128, + "Make ": 12129, + "(\\n bool success": 12130, + "\\n function ": 12131, + "IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, ": 12132, + "compa": 12133, + "functionCall(target, data, \\\"Address: low-level ": 12134, + "exceeds ": 12135, + "generates ": 12136, + "digits ": 12137, + "ternativel": 12138, + "subscrib": 12139, + "(bytes32 => ": 12140, + "verifyCallResult(\\n bool success": 12141, + "/// @title ": 12142, + "Overri": 12143, + "ential": 12144, + "this contract and ": 12145, + "EIP712Domain": 12146, + "\"@openzeppelin/contracts/utils/Strings.sol\"": 12147, + "fictiveReserve": 12148, + "realistically ": 12149, + "charact": 12150, + " != 0) {\\n ": 12151, + "retval == ": 12152, + "ERC20-_burn": 12153, + " bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt": 12154, + "lower than 0.": 12155, + ") internal virtual {}\\n\\n /**\\n * @dev Hook that is called after any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * has been transferred to `to`.\\n * - when `from` is zero, `amount` tokens have been minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer": 12156, + ".startTimestamp = ": 12157, + "verify that a ": 12158, + "artblocks": 12159, + "}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ": 12160, + " << (": 12161, + "string memory baseURI = _baseURI": 12162, + "https://github.com/ethereum/solidity/issues/": 12163, + "optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\"": 12164, + ");\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n ": 12165, + "information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `": 12166, + "`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this ": 12167, + "ternatively, ": 12168, + "% or ": 12169, + "-bit ": 12170, + ".isContract": 12171, + "D0": 12172, + "_addr": 12173, + "az": 12174, + "bf": 12175, + "fra": 12176, + "migr": 12177, + "sample": 12178, + "uint40": 12179, + ", then ": 12180, + "\\n * message unnecessarily. For custom revert reasons use {": 12181, + "tokenOwner": 12182, + "coder": 12183, + "extension ": 12184, + "Token.sol\"": 12185, + " ": 12186, + "\\n * conventional and does not conflict with the expectations of ERC20": 12187, + "\\n * instead returning `false` on failure. This behavior is nonetheless": 12188, + ",\\n uint liquidity": 12189, + "openTrading": 12190, + "\\n // - ": 12191, + "_transferFrom": 12192, + "uint256) {\\n uint256 ": 12193, + "][_msgSender()": 12194, + "MIN_INT256": 12195, + "s that want to ": 12196, + "your contract": 12197, + "\"// SPDX-License-Identifier: MIT\\npragma solidity 0.6.": 12198, + "feeToSetter": 12199, + "Multiplier": 12200, + "\"Cannot set ": 12201, + "HoldingAmount": 12202, + "```solidity\\n * function ": 12203, + "whitelist mint ": 12204, + "data to send ": 12205, + "CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {": 12206, + "OpenZeppelin Contracts guidelines: functions revert\\n * instead returning `false` on failure. This behavior is nonetheless": 12207, + "emit Transfer(address(0), account, amount);\\n\\n _afterTokenTransfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn ": 12208, + ".slot := ": 12209, + "realistically overflow": 12210, + "\\n * conventional and does not conflict with the expectations of ERC20\\n * ": 12211, + "OpenZeppelin Contracts guidelines: functions revert\\n * instead returning `false` on failure. This behavior is nonetheless\\n * conventional and does not conflict with the expectations of ERC20\\n * ": 12212, + "emit Transfer(address(0), account, amount);\\n\\n _afterTokenTransfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n unchecked {\\n _balances[account] = accountBalance - amount": 12213, + "\"B": 12214, + "PAUS": 12215, + "_default": 12216, + "gobbl": 12217, + "\\n //\\n // ": 12218, + ", 0, ": 12219, + "expres": 12220, + "a target ": 12221, + "account's ": 12222, + "Amp": 12223, + "} provides an ": 12224, + "totalSupply_": 12225, + "bytes memory reason": 12226, + "pointer": 12227, + "Encoder": 12228, + "███": 12229, + "UniswapV2Router": 12230, + ", and then ": 12231, + "but more expensive ": 12232, + "should inherit from ": 12233, + "for the additional ": 12234, + "implement ERC165 ": 12235, + "`from` to `to` ": 12236, + "staked": 12237, + "ain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall": 12238, + "royaltyAmount": 12239, + "RoleAdminChanged": 12240, + "supportsInterface} to ": 12241, + "Alternatively, ": 12242, + "Storage} provides an ": 12243, + "\\n * return interfaceId == type(": 12244, + "supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {": 12245, + "% total supply": 12246, + "BITPOS_NEXT_INITIALIZED": 12247, + "Interface).interfaceId || super.supportsInterface(interfaceId": 12248, + "Black": 12249, + "AAAA": 12250, + "easier to use ": 12251, + " */\\r\\n function ": 12252, + "Wrapped": 12253, + "// solhint-disable-next-line avoid-low-level-call": 12254, + "{ERC165Storage} provides an ": 12255, + "MyInterface).interfaceId || super.supportsInterface(interfaceId": 12256, + "_redisFeeOnSell": 12257, + "Base URI for ": 12258, + "ERC721A Contract": 12259, + "EVENT_SIGNATUR": 12260, + "FXS": 12261, + "that will be supported. ": 12262, + "does not exist.\\n */\\n error ": 12263, + "();\\n\\n /**\\n * The token does not exist.\\n */\\n error ": 12264, + "interface id that will be supported. ": 12265, + "_TRANSFER_": 12266, + "ABIEncoder": 12267, + ", IERC20Metadata {\\n mapping(address => uint256) private _balances;\\n\\n mapping(address => mapping(address => uint256": 12268, + "override {supportsInterface} to ": 12269, + "this contract and override {supportsInterface} to ": 12270, + "% or less": 12271, + "s that want to implement ERC165 ": 12272, + "but more expensive implementation": 12273, + "should inherit from this contract and override {supportsInterface} to ": 12274, + "for the additional interface id that will be supported. ": 12275, + "Alternatively, {ERC165Storage} provides an ": 12276, + "\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId": 12277, + "easier to use but more expensive implementation": 12278, + "ABIEncoderV2": 12279, + "s that want to implement ERC165 should inherit from this contract and override {supportsInterface} to ": 12280, + "Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation": 12281, + "\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);": 12282, + "s that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check": 12283, + " that ": 12284, + "/ethereum": 12285, + "300": 12286, + "_fees": 12287, + "`address": 12288, + "e-": 12289, + "you": 12290, + "determin": 12291, + "black": 12292, + "pper": 12293, + "amountADesired": 12294, + "ToAddress": 12295, + "or the ": 12296, + "ERC20Votes": 12297, + "Input": 12298, + "and transfers ": 12299, + "} catch": 12300, + "protection": 12301, + "require(\\n ": 12302, + "have": 12303, + "MintValidation": 12304, + "safeIn": 12305, + "; ++i": 12306, + "_approve(sender": 12307, + "startTime": 12308, + "leaf ": 12309, + "OTAL": 12310, + "\"@openzeppelin/contracts/token/ERC20/ERC20.sol\"": 12311, + "number of whitelist mint ": 12312, + "srcAddress": 12313, + "approve to ": 12314, + "`.\\n */\\n function get": 12315, + "reserveA": 12316, + "registry/": 12317, + ")\\n }\\n ": 12318, + "values(": 12319, + "autoLiquidity": 12320, + "authorized ": 12321, + "amountBDesired": 12322, + "46c": 12323, + "tokenIdsMaxLength": 12324, + "() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol": 12325, + "/src/\"": 12326, + "along with the call": 12327, + ".\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ": 12328, + "(e.g. number of whitelist mint ": 12329, + "bytes1(uint8(": 12330, + "token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol": 12331, + "call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ": 12332, + "slots used": 12333, + "Whenever ": 12334, + "currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n unchecked {\\n ": 12335, + "operate on ": 12336, + "IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\"": 12337, + "verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ": 12338, + "data to send along with the call": 12339, + "} catch (": 12340, + "(e.g. number of whitelist mint slots used": 12341, + "(\\n ": 12342, + "B6": 12343, + "ses ": 12344, + "\\n * for the additional interface id that will be supported. ": 12345, + "Amt": 12346, + ";\\n } else {\\n return ": 12347, + " of an ": 12348, + "Value ": 12349, + "id_": 12350, + "/contracts/interfaces/": 12351, + ";\\n bool public ": 12352, + "Uni": 12353, + "revert if it ": 12354, + "PerTx": 12355, + "overflow is ": 12356, + "data is ": 12357, + "`account`": 12358, + "account that ": 12359, + "() <= ": 12360, + ");\\n }\\n\\n /**\\n * @dev Returns the number of ": 12361, + "operations ": 12362, + ");\\n return true;\\n }\\n\\n function ": 12363, + "if (!_exists(tokenId": 12364, + "Tokens can be ": 12365, + "authorization": 12366, + "4626": 12367, + "ABLE": 12368, + "\"@balancer-labs/v2-": 12369, + "(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory": 12370, + "-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory": 12371, + ".\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI": 12372, + "nextTokenId = ": 12373, + "safeTransferFrom(from, to, tokenId, ''": 12374, + "Modifier to ": 12375, + "\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation": 12376, + ")\\n }\\n } else {\\n ": 12377, + "_reflectFee": 12378, + "Nominal": 12379, + "must be owned by `from`": 12380, + "For example:\\n *\\n * ```solidity\\n * function ": 12381, + "Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check": 12382, + "supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);": 12383, + "token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI": 12384, + "call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`": 12385, + "\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function ": 12386, + "\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165": 12387, + "Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function ": 12388, + "supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165": 12389, + "token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory": 12390, + "Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165": 12391, + "135": 12392, + "2.": 12393, + "Each ": 12394, + "Word": 12395, + ") ||": 12396, + "y / ": 12397, + "ed and ": 12398, + "proof ": 12399, + "as well": 12400, + "approve} or {": 12401, + "e {IERC721Receiver-onERC721Received": 12402, + "log_": 12403, + "\\n // Look for revert reason and bubble it up if present": 12404, + "for\\n // ": 12405, + "safeDecrease": 12406, + "\\n */\\n function get": 12407, + "_msgSender() == ": 12408, + "ID of the ": 12409, + "entry ": 12410, + "&& _": 12411, + "approved accounts ": 12412, + "their owner or ": 12413, + "Tokens start ": 12414, + "royalty information": 12415, + "nonces(address owner": 12416, + "returned the expected ": 12417, + "- the first ": 12418, + "// The easiest way to bubble the revert reason is using memory via assembly": 12419, + "nextInitializedFlag": 12420, + ")) private _operatorApprovals": 12421, + "\\n if (returndata.length": 12422, + "via {approve} or {": 12423, + ".\\r\\n * - `": 12424, + "IERC721Enumerable-": 12425, + "_balances[from] = ": 12426, + "Returns whether `tokenId` ": 12427, + ")\\n revert(add(32, returndata), returndata_size": 12428, + "} on a target ": 12429, + "invoke {IERC721Receiver-onERC721Received": 12430, + "the call correctly ": 12431, + "\\n assembly {\\n let returndata_size := mload(returndata": 12432, + "buildDomainSeparator": 12433, + "managed by their owner or ": 12434, + "All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5.0": 12435, + ", IERC20Metadata {\\n mapping(address => uint256) private _balances;\\n\\n mapping(address => mapping(address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * ": 12436, + "/ethereum-": 12437, + "Tokens can be managed by their owner or ": 12438, + ")\\n }\\n } else {\\n revert(errorMessage": 12439, + "\\n // Look for revert reason and bubble it up if present\\n if (returndata.length": 12440, + "approved accounts via {approve} or {": 12441, + "Tokens start existing when they are ": 12442, + "returned the expected magic value": 12443, + ")\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage": 12444, + "invoke {IERC721Receiver-onERC721Received} on a target ": 12445, + "the call correctly returned the expected magic value": 12446, + "\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage": 12447, + "Tokens can be managed by their owner or approved accounts via {approve} or {": 12448, + "Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll": 12449, + "Ag": 12450, + "gor": 12451, + "ure ": 12452, + "an\\n * ": 12453, + "uint256 or ": 12454, + "ribu": 12455, + " = 1 ": 12456, + "not exist": 12457, + "ETHFee": 12458, + "(\\n IERC20 token": 12459, + ") internal pure returns (int256": 12460, + "red to ": 12461, + "points": 12462, + "BuyFee": 12463, + ".\\n _": 12464, + "updateSwap": 12465, + ") {\\n require(isContract(target), \\\"Address: ": 12466, + "total amount of tokens ": 12467, + "ECDSA.": 12468, + "spender, value": 12469, + "title": 12470, + "reason), mload(": 12471, + "- the amount to be transferred": 12472, + "fees at ": 12473, + "ally-ordered ": 12474, + "enumerate ": 12475, + "serially-ordered ": 12476, + "revert(add(32, reason), mload(": 12477, + "bytes32[] memory proof": 12478, + ",\\n uint256 quantity\\n ": 12479, + " amount cannot be ": 12480, + "applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping(address => uint256) private _balances;\\n\\n mapping(address => mapping(address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * ": 12481, + "}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall": 12482, + ") internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ": 12483, + "-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory": 12484, + "operator-filter-registry/": 12485, + "See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165": 12486, + "a set of serially-ordered ": 12487, + "} catch (bytes memory reason": 12488, + "revert(add(32, reason), mload(reason": 12489, + "lt(": 12490, + "s `tokenId` ": 12491, + ", such as ": 12492, + "esis": 12493, + "entri": 12494, + "exact": 12495, + "very ": 12496, + ");\\n }\\n\\n // ": 12497, + "index]": 12498, + "mintAmount": 12499, + "Calldata": 12500, + "pragma ": 12501, + "Swap amount cannot be ": 12502, + ";\\n uint256 private constant _": 12503, + "allowance is ": 12504, + "Resol": 12505, + "increase ": 12506, + "Upgradeability": 12507, + "amountInMax": 12508, + "Reentrancy ": 12509, + "tokenId` must not exist": 12510, + "OUND": 12511, + "And ": 12512, + "security ": 12513, + "} to enumerate ": 12514, + "Slot storage ": 12515, + "mapping(address => bool) public ": 12516, + "to != address(0), \\\"ERC721: ": 12517, + "setApprovalForAll(address operator, bool approved": 12518, + "longer ": 12519, + "verifies ": 12520, + "maintain ": 12521, + "(bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall": 12522, + "and transfers it to ": 12523, + "s `tokenId` and transfers it to ": 12524, + "Merkle ": 12525, + "{\\n ": 12526, + "ow the ": 12527, + "itself ": 12528, + "/**\\n * ": 12529, + "return _tokenApprovals[tokenId": 12530, + "on overflow": 12531, + "pay ": 12532, + "uint value": 12533, + "compos": 12534, + "implemented by the ": 12535, + "allowList": 12536, + ";\\n uint256 ": 12537, + ";\\n emit ": 12538, + ",\\n _": 12539, + "\"// SPDX-License-Identifier: MIT\\n// ERC721A Contract": 12540, + "Allowed(": 12541, + "administr": 12542, + "BITMASK_BURNED": 12543, + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20": 12544, + "```\\n * ": 12545, + "see https://github.com/ethereum/solidity/issues/": 12546, + "flags": 12547, + "ethForDev": 12548, + "programm": 12549, + "and the recipient": 12550, + "solhint-disable-next-line no-inline-assembly": 12551, + "afely mint": 12552, + "whenNotPaused ": 12553, + "token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20": 12554, + "EVM ": 12555, + "variables": 12556, + "hashedVersion": 12557, + "owner to operator ": 12558, + "MUST ": 12559, + "invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod": 12560, + "solidity-utils/contracts/": 12561, + "Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\"": 12562, + "p0) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(bytes": 12563, + "es[role].members[account": 12564, + "should only be called ": 12565, + "%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod": 12566, + "gorith": 12567, + ") internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call": 12568, + ".\\n ": 12569, + "3F": 12570, + "A7": 12571, + "Fail": 12572, + ") return ": 12573, + "fromBalance = ": 12574, + "ETHMin,\\n address to,\\n uint deadline": 12575, + "burnFee": 12576, + "bytes32 r": 12577, + "\\n // of the ": 12578, + "\\n// Creator: Chiru Labs\\n\\npragma solidity ^0.8.4": 12579, + ") private pure ": 12580, + "owner address to ": 12581, + "ReentrancyGuard ": 12582, + "calculate ": 12583, + ", either by bubbl": 12584, + "safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes calldata data": 12585, + "_developmentAddress": 12586, + "Min,\\n uint amountETHMin,\\n address to,\\n uint deadline": 12587, + "escrow": 12588, + "Released": 12589, + "you should overload": 12590, + "select a different value for": 12591, + "low level call was successful, and ": 12592, + ",\\n uint amountTokenMin,\\n uint amountETHMin,\\n address to,\\n uint deadline": 12593, + "transfer amount exceeds the maxTransactionAmount": 12594, + "Max wallet exceed": 12595, + ",\\n bytes calldata data\\n ) external returns (bytes4": 12596, + "revert if it was": 12597, + "s `tokenId` and transfers it to `to": 12598, + "you should overload it": 12599, + "low level call was successful, and revert if it was": 12600, + "8/": 12601, + "Cy": 12602, + "Phase": 12603, + "UFF": 12604, + "r.slot := ": 12605, + "usted ": 12606, + "sender is not ": 12607, + ");\\n }\\n\\n /**\\n * @dev Tool to ": 12608, + "parent": 12609, + ".\\n */\\n function _baseURI": 12610, + ") internal virtual override {\\n ": 12611, + "_minter": 12612, + "ALL": 12613, + "ghtEarly": 12614, + ".\\n uint256 private ": 12615, + "hasRole(role, account": 12616, + "request ": 12617, + "optional": 12618, + "(uint256 value) internal pure returns (string memory": 12619, + "................................": 12620, + "libraries/": 12621, + "Bytes32Set": 12622, + "scalingFactors": 12623, + "Returns an `": 12624, + "ing the\\n * revert reason ": 12625, + "If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _": 12626, + "filtered operator": 12627, + "missing role ": 12628, + "getRoleAdmin(role": 12629, + "Processed": 12630, + "computing {tokenURI": 12631, + "venanceHash": 12632, + "OpenZeppelin Contracts guidelines: functions revert\\n * instead returning `false` on failure. This behavior is nonetheless\\n * conventional and does not conflict with the expectations of ERC20\\n * applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping(address => uint256) private _balances;\\n\\n mapping(address => mapping(address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * ": 12633, + "Base URI for computing {tokenURI": 12634, + "Slot storage r": 12635, + ", either by bubbling the\\n * revert reason ": 12636, + "Base URI for computing {tokenURI}. ": 12637, + " =\\n ": 12638, + "4d": 12639, + "lim": 12640, + "p < ": 12641, + "\\n@param ": 12642, + ") != ": 12643, + "iter": 12644, + "buy ": 12645, + ".solution": 12646, + "PairCreated": 12647, + "Buy ": 12648, + "zeppelin.solution": 12649, + "; //": 12650, + "0 : ": 12651, + "= _totalSupply": 12652, + "(\\n address from,\\n address to,\\n uint256 startTokenId": 12653, + "previousAdminRole": 12654, + ";\\n emit ApprovalForAll": 12655, + "prevents ": 12656, + "verifyCallResultFromTarget": 12657, + "146": 12658, + "Counter overflow is ": 12659, + "released": 12660, + "keccak256(abi.encode(": 12661, + "identifier": 12662, + "tracking ": 12663, + "would have ": 12664, + "ategy ": 12665, + "_balances[sender] = ": 12666, + "HASHED_NAM": 12667, + "HASHED_VERSION": 12668, + "keep fees at ": 12669, + " > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly": 12670, + "compliant contract": 12671, + "TokenOwnership memory ownership": 12672, + "cheap": 12673, + "\"// SPDX-License-Identifier: GPL-3.0-or-later\\n// This program is free software: you can redistribute it and/or modify\\n// it under the terms of the GNU General Public License as published by\\n// the Free Software Foundation, either version 3 of the License, or\\n// (at your option) any later version.\\n\\n// This program is distributed in the hope that it will be useful,\\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\n// GNU General Public License for more details.\\n\\n// You should have received a copy of the GNU General Public License\\n// along with this program. If not, see .\\n\\npragma solidity ^0.7.0": 12674, + "autoLiquidityReceiver": 12675, + "\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly": 12676, + "zeppelin.solutions/": 12677, + ")) == ": 12678, + "DF": 12679, + "in child ": 12680, + "log(uint256 ": 12681, + "Interes": 12682, + ") internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {": 12683, + "s that are ": 12684, + "152": 12685, + "royaltyInfo": 12686, + "Any ": 12687, + "previous owner of the given token ID": 12688, + "implementation - ": 12689, + "upper": 12690, + "This is equivalent to ": 12691, + ");\\n }\\n }\\n\\n function _": 12692, + ",address verifyingContract": 12693, + "limit of ": 12694, + "Disabled": 12695, + "fromBalance - amount": 12696, + ") {\\n revert(\\\"ECDSA: invalid signature ": 12697, + "address representing the previous owner of the given token ID": 12698, + "verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {": 12699, + "(operator": 12700, + ".io/": 12701, + "Fac": 12702, + "Limit ": 12703, + ", signature": 12704, + "tokenFrom": 12705, + "is impossible ": 12706, + "er is ": 12707, + "stage ": 12708, + "Coordin": 12709, + "\\n if (": 12710, + "set, the ": 12711, + "sender's balance ": 12712, + " of the sender's balance ": 12713, + "Timelock": 12714, + "------------": 12715, + "starts ": 12716, + "`tokenId` from `from` to `to`": 12717, + "_tokenTransfer": 12718, + ".\\r\\n */": 12719, + ";\\r\\n }\\r\\n\\r\\n /**\\r\\n * @dev Returns the ": 12720, + "ownership above ": 12721, + "because we check ": 12722, + "branc": 12723, + "'s balance can't ": 12724, + "if (b == 0": 12725, + "whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this ": 12726, + "].sub(amount, \\\"ERC20: transfer ": 12727, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (": 12728, + ".\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {": 12729, + "MINIMUM_LIQUIDITY": 12730, + "_init_unchained(": 12731, + "using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {": 12732, + "happen": 12733, + "] = approved;\\n emit ApprovalForAll": 12734, + "Underflow of the sender's balance ": 12735, + "Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165 is IERC165 {\\n /**\\n * @dev ": 12736, + "and the recipient's balance can't ": 12737, + "gorithm": 12738, + "(\\n address from,\\n address to,\\n uint256 startTokenId,\\n uint256 quantity\\n ": 12739, + "tokenFromReflection": 12740, + "is impossible because we check ": 12741, + "ownership above and the recipient's balance can't ": 12742, + "Underflow of the sender's balance is impossible because we check ": 12743, + "ownership above and the recipient's balance can't realistically overflow": 12744, + "(IERC20 token": 12745, + "4.0": 12746, + "Ab": 12747, + "cvx": 12748, + "gt(": 12749, + "sem": 12750, + "vex": 12751, + "adapter": 12752, + ", (": 12753, + "\\n * uses an ": 12754, + "function selector": 12755, + "contin": 12756, + "TokenApproval": 12757, + "returns (uint256 ": 12758, + "from address representing the previous owner of the given token ID": 12759, + "SenderApprovedOrOwner": 12760, + ", uint256 p1": 12761, + "Of(uint256 tokenId": 12762, + "The approval is cleared when the token is ": 12763, + "This will ": 12764, + ", path": 12765, + "\\n // The ": 12766, + "] = bytes1(uint8(": 12767, + "OutMin": 12768, + "round ": 12769, + "has a ": 12770, + ";\\n }\\n\\n /**\\n * Returns the ": 12771, + "address,uint,": 12772, + "Delegates": 12773, + "AndAddress": 12774, + "p0, uint256 p1": 12775, + "SlotAndAddress": 12776, + "docs.": 12777, + "_maxTxAmount.\"": 12778, + "(_msgSender(), recipient, amount": 12779, + "swapping ": 12780, + "48 + ": 12781, + "compute ": 12782, + "quantity == 1": 12783, + "product ": 12784, + "tokenIdsIdx": 12785, + "correctness ": 12786, + "MerkleRoot": 12787, + "a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity": 12788, + "Authorizer": 12789, + "cache": 12790, + "EEEEEEEE": 12791, + "\\n mapping(uint256 => address) private ": 12792, + "(string name": 12793, + " bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint": 12794, + "\"Exceeds the maxWalletSize": 12795, + "O(1) ": 12796, + ").interfaceId;\\n }\\n}\\n\"": 12797, + "is already open": 12798, + "Util": 12799, + "FACE_": 12800, + "smart": 12801, + "overridden;": 12802, + "within bound": 12803, + "/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity": 12804, + "_allowances[sender][_msgSender()": 12805, + "_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: ": 12806, + "EIP712Domain(string name": 12807, + "low level call was successful, and revert if it wasn't": 12808, + "Counter overflow is incredibly unrealis": 12809, + "implementation - MIT licen": 12810, + "Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165 is IERC165 {\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165": 12811, + "The approval is cleared when the token is burned": 12812, + "\"Exceeds the maxWalletSize.\"": 12813, + "/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an ": 12814, + "(bytes32 _": 12815, + "];\\n }\\n\\n function ": 12816, + "gs": 12817, + "ition": 12818, + "kLast": 12819, + "──": 12820, + "▄▄": 12821, + "\\n@notice ": 12822, + "retr": 12823, + "in\\n * ": 12824, + "expos": 12825, + "ToAdd": 12826, + ".\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll": 12827, + "in an ": 12828, + ". Note that ": 12829, + "and it is ": 12830, + "newMarketingWallet": 12831, + "string calldata ": 12832, + "name ": 12833, + "operatorApproval": 12834, + " ": 12835, + "force": 12836, + "oldValue": 12837, + "arket ": 12838, + ");\\n\\n /**\\n * @dev Revert ": 12839, + "digest ": 12840, + "onERC721Received(\\n address operator,\\n address from": 12841, + "exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll": 12842, + "}.\\n *\\n * Tokens start existing when they are ": 12843, + ",\\n bytes memory data\\n ": 12844, + "///////////////": 12845, + "infinite allowance": 12846, + "bytecode ": 12847, + ";\\n }\\n if (p < ": 12848, + "IERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165 is IERC165 {\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165": 12849, + "nextTokenId = tokenId + ": 12850, + "Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll": 12851, + "hasRole(role, account)) {\\n ": 12852, + "low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason ": 12853, + "IERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165 is IERC165 {\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165).interfaceId;\\n }\\n}\\n\"": 12854, + "Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are ": 12855, + " value": 12856, + "\"SafeCast: value doesn't fit in ": 12857, + "){\\n ": 12858, + "Might ": 12859, + "[ERC721": 12860, + "alp": 12861, + ", to": 12862, + ");\\n\\n": 12863, + "a < ": 12864, + "TokenOut": 12865, + "er the ": 12866, + "lose ": 12867, + " = 4": 12868, + "approve.selector, ": 12869, + "token has been ": 12870, + "token will be the ": 12871, + "127": 12872, + "and\\n * {": 12873, + "_msgSender())": 12874, + "If set, the ": 12875, + "which the ": 12876, + "approvedAddress ": 12877, + "` and the `": 12878, + ";\\n\\nimport \\\"../../": 12879, + "baseURI` and the `": 12880, + "tryDiv": 12881, + "given address": 12882, + "();\\n }\\n\\n ": 12883, + "currentAllowance != type(uint256).max": 12884, + "royalty payment": 12885, + "] = true;\\n ": 12886, + "PaymentSplitter": 12887, + ".\\n *\\n * See {ERC20-_burn": 12888, + "mstore(0x00": 12889, + "chainId,address verifyingContract": 12890, + "URI for each": 12891, + "/= 10;\\n }\\n ": 12892, + "_TOKENS": 12893, + " of the `baseURI` and the `": 12894, + "\"Exceeds the _maxTxAmount.\"": 12895, + ".\\n * Note that ": 12896, + "setFeeToSetter": 12897, + "Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(": 12898, + "PrimarySales": 12899, + "allPairsLength": 12900, + "ShortString": 12901, + "interface ID for ": 12902, + "values[": 12903, + "resulting URI for each": 12904, + "concatenation of the `baseURI` and the `": 12905, + "address spender = _msgSender(": 12906, + "Base URI for computing {tokenURI}. If set, the ": 12907, + "onERC721Received(\\n address operator,\\n address from,\\n uint256 tokenId": 12908, + "token will be the concatenation of the `baseURI` and the `": 12909, + "Base URI for computing {tokenURI}. If set, the resulting URI for each": 12910, + "token will be the concatenation of the `baseURI` and the `tokenId": 12911, + "BAS": 12912, + "Next": 12913, + "_swapTokensAtAmount": 12914, + "c9": 12915, + "ness": 12916, + "tuck": 12917, + "Core": 12918, + "must not be ": 12919, + "Minting": 12920, + "s[0": 12921, + "returns (bool)\\n {\\n ": 12922, + "transferFrom`": 12923, + "IDEX": 12924, + "if the current ": 12925, + "we can ": 12926, + "variable": 12927, + "s = 0": 12928, + "ICAL": 12929, + "_getCurrent": 12930, + "bit in packed ": 12931, + "}.\\n *\\n * Counterpart to Solidity's `": 12932, + "power": 12933, + "Revoked(": 12934, + "\\\"\\n );\\n ": 12935, + "StandardToken": 12936, + "Endpoint": 12937, + "ERC165 interface ID for ": 12938, + "utils/introspection/ERC165.sol\"": 12939, + "utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.": 12940, + ".\\n *\\n * The `": 12941, + "token/ERC20/extensions/IERC20Metadata.sol\"": 12942, + ".\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ": 12943, + "Detailed": 12944, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (": 12945, + "if (!_exists(tokenId)) revert ": 12946, + "\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\"": 12947, + ") {\\n require(isContract(target), \\\"Address: static ": 12948, + "maintain correctness ": 12949, + "sender is not the owner": 12950, + "onERC721Received(\\n address operator,\\n address from,\\n uint256 tokenId,\\n bytes calldata data\\n ) external returns (bytes4": 12951, + "(proof": 12952, + ".mul": 12953, + "08": 12954, + "< b": 12955, + "[id": 12956, + "a, ": 12957, + "{\\\"": 12958, + "\\n {\\n ": 12959, + "it, ": 12960, + "address or ": 12961, + ");\\n } else {\\n ": 12962, + " to `recipient": 12963, + "becom": 12964, + "this.": 12965, + "The `": 12966, + "name\\n ": 12967, + "symbol\\n ": 12968, + "liquidityPair": 12969, + ".\\n //\\n // ": 12970, + "last token": 12971, + "\\\");\\n require(isContract(target), \\\"Address: ": 12972, + "888": 12973, + "DELEG": 12974, + "does not provide ": 12975, + "LOCK": 12976, + "quantity > ": 12977, + "per block ": 12978, + "ary data ": 12979, + "(\\r\\n uint256 ": 12980, + ".\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _": 12981, + " to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function ": 12982, + "utils/introspection/ERC165.sol\\\";\\n\\n/**\\n * @dev ": 12983, + "Contract module that ": 12984, + "mapping(address => bool)) private _operatorApprovals": 12985, + ") internal view returns (uint256) {\\n return _": 12986, + "bytes memory buffer = new bytes(digits": 12987, + "IERC721Receiver(to).onERC721Received": 12988, + "`.\\n * The approval is cleared when the token is burned": 12989, + "statement": 12990, + "s `tokenId`.\\n * The approval is cleared when the token is burned": 12991, + "call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ": 12992, + "for\\n // ownership above and the recipient's balance can't realistically overflow": 12993, + "owner to operator approval": 12994, + "Underflow of the sender's balance is impossible because we check for\\n // ownership above and the recipient's balance can't realistically overflow": 12995, + ".\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId": 12996, + "(b": 12997, + "(https://": 12998, + "(\\r\\n ": 12999, + "41": 13000, + "6ee": 13001, + "D5": 13002, + "KO": 13003, + "Unt": 13004, + "_excludeFromMaxTransaction": 13005, + "uint256) {": 13006, + "end of the ": 13007, + "uint256 fromBalance = ": 13008, + "eld ": 13009, + "else if (": 13010, + "index < ": 13011, + "lipp": 13012, + ";\\n}\\n\\n": 13013, + "'s index": 13014, + "`to`.": 13015, + "taxFee": 13016, + "_mintERC2309": 13017, + "address,bool": 13018, + ");\\n }\\n\\n /**\\n * @dev Safely mint": 13019, + ";\\r\\n uint256 ": 13020, + "`. Empty": 13021, + "already minted": 13022, + "makes ": 13023, + "\"evmVersion": 13024, + "_FE": 13025, + ".sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.": 13026, + "() internal view virtual returns (string memory) {\\n return ": 13027, + ",uint256 chainId,address verifyingContract": 13028, + "\"@openzeppelin/contracts/utils/Address.sol\"": 13029, + "emits an ": 13030, + "liquidation": 13031, + "compute": 13032, + "revoke ": 13033, + "b06": 13034, + "Non-Fungible Token Standard, includ": 13035, + "] = to;\\n\\n emit Transfer": 13036, + "0.4.25": 13037, + "6239": 13038, + "TransferFromIncorrectOwner": 13039, + "token will be the concatenation of the `baseURI` and the `tokenId`. Empty": 13040, + "Until": 13041, + "\"evmVersion\"": 13042, + " if ": 13043, + "();\\n _": 13044, + "67": 13045, + "E7": 13046, + "El": 13047, + "i = 0; i": 13048, + "yield": 13049, + "\\ncontract ": 13050, + "romis": 13051, + "loan ": 13052, + "] == 0) {\\n ": 13053, + "this extension": 13054, + "balanceOf(to": 13055, + "\\\");\\n } else if (error == RecoverError.InvalidSignature": 13056, + "\\n */\\n function _": 13057, + "If you ": 13058, + "_balances[owner": 13059, + "At(uint256 index": 13060, + ";\\r\\n ": 13061, + ") public view virtual override returns (uint256) {\\n require(": 13062, + "multiproof": 13063, + "ERC721: transfer to non ERC721Receiver implementer": 13064, + "Percentage ": 13065, + "receive() external payable ": 13066, + "earn": 13067, + "Only one ": 13068, + "keccak256(abi.encodePacked(": 13069, + "If `to` refers to a smart contract, it must implement": 13070, + "_startTokenId()": 13071, + ";\\n\\n // Mapping from owner to operator approval": 13072, + ";\\n }\\n ": 13073, + "_LIMIT": 13074, + "minimum ": 13075, + ";\\n\\n // Mapping from token ID to approved address": 13076, + "accounts that have ": 13077, + "VotingPower": 13078, + "data structures": 13079, + "price0CumulativeLast": 13080, + "price1CumulativeLast": 13081, + "downcasted = int": 13082, + "tracking data structures": 13083, + "] = bytes1(uint8(48 + ": 13084, + " to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount": 13085, + " memory ": 13086, + "\"trading ": 13087, + ".\\n /// ": 13088, + "Ste": 13089, + "UT": 13090, + "bil": 13091, + "tree": 13092, + "though ": 13093, + "decrease": 13094, + ");\\n } else if (": 13095, + "if iszero(": 13096, + "data.": 13097, + "newAdminRole": 13098, + "value to ": 13099, + "IERC721 {\\n /**\\n * @dev Returns the ": 13100, + "_transferStandard": 13101, + "{\\n ": 13102, + "prod0, ": 13103, + "BuyFees": 13104, + "\"@openzeppelin/contracts/utils/introspection/IERC165.sol\"": 13105, + "uint256) {\\n if (": 13106, + "_burn(tokenId, ": 13107, + ");\\n }\\n\\n /// @dev ": 13108, + "onlyOwner {\\r\\n ": 13109, + "///////////////////////////////////////////////": 13110, + "\\n * ": 13111, + "this function is\\n * ": 13112, + ") external returns (bool);\\n function ": 13113, + "https://github.com/oraclize": 13114, + "projectIdTo": 13115, + "referrer": 13116, + "permission ": 13117, + "max value of ": 13118, + "See https://": 13119, + "Prefix": 13120, + "local": 13121, + "Owner();\\n _": 13122, + "API_": 13123, + "token ids ": 13124, + " of the `nextInitialized` ": 13125, + ";\\n\\ninterface I": 13126, + "42146": 13127, + "takes ": 13128, + "UBLIC": 13129, + ";\\n\\n // Token symbol\\n ": 13130, + "oraclizeAPI_": 13131, + "CRIP": 13132, + "future": 13133, + "_removeTokenFromOwnerEnumeration": 13134, + "api/blob/": 13135, + "spendAllowance(from, ": 13136, + "Throws if the sender is not the owner": 13137, + "5` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * ": 13138, + "The default value of {decimals} is 18. To select a different value for": 13139, + "secp256k1": 13140, + "-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ": 13141, + "_approve(sender, _msgSender(), ": 13142, + "_balances[from] = fromBalance - amount": 13143, + "/ethereum-api/blob/": 13144, + "compliant contract.\\n */\\ninterface ": 13145, + "per block allowed": 13146, + "https://github.com/oraclize/ethereum-api/blob/": 13147, + "Capp": 13148, + "b42146": 13149, + "od": 13150, + "ore": 13151, + "sload": 13152, + "reject": 13153, + "tivel": 13154, + ", to ": 13155, + ");\\r\\n ": 13156, + "isBot": 13157, + "vileg": 13158, + "is trigge": 13159, + ": URI ": 13160, + "be the ": 13161, + "tokenId.toString": 13162, + "bucket": 13163, + ", uint256 p2": 13164, + "(uint256 _tokenId": 13165, + ".sol\\\";\\r\\n\\r\\n": 13166, + "of the product": 13167, + "blockNum": 13168, + "_transfer(owner, ": 13169, + "tokens.\\n */\\n function ": 13170, + "Id = ": 13171, + "Returns `": 13172, + "receiv": 13173, + "246239": 13174, + "Consum": 13175, + ".\\n uint256 ": 13176, + ", address indexed sender": 13177, + ");\\r\\n return true": 13178, + "8846c": 13179, + "also called ": 13180, + "360e": 13181, + "entially ": 13182, + "digits;\\n while (temp != 0) {\\n ": 13183, + "digits++;\\n temp ": 13184, + "\\n * {decimals} ": 13185, + "Oraclize": 13186, + "p0, address p1, address p2": 13187, + "p0, address p1, string memory p2": 13188, + "p0, address p1, bool p2": 13189, + "p0, bool p1, address p2": 13190, + "p0, bool p1, string memory p2": 13191, + "p0, bool p1, bool p2": 13192, + "p0, string memory p1, address p2": 13193, + "p0, string memory p1, string memory p2": 13194, + "p0, string memory p1, bool p2": 13195, + "3c7d": 13196, + "\\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 ": 13197, + "srcRepNum": 13198, + "⠀⠀⠀⠀⠀⠀⠀⠀": 13199, + ");\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned": 13200, + "at a given ": 13201, + "string private _name;\\n\\n // Token symbol\\n ": 13202, + "xxx": 13203, + ";\\n }\\n return string(buffer": 13204, + ";\\n\\n // Token name\\n ": 13205, + "if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 ": 13206, + "destination": 13207, + "facilit": 13208, + "e9360e": 13209, + "Inspired by Oraclize": 13210, + "address(0) && ": 13211, + "sstore(": 13212, + "doubl": 13213, + ".sol\\\";\\nimport \\\"./extensions/IERC20Metadata": 13214, + "owner != address(0), \\\"ERC721: ": 13215, + "198246239": 13216, + "`from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom": 13217, + "1358846c": 13218, + "you should overload it.\\n *\\n * ": 13219, + "8/oraclizeAPI_": 13220, + "would have to be ": 13221, + "FACE_ID": 13222, + "/= 10;\\n }\\n bytes memory buffer = new bytes(digits": 13223, + "call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call": 13224, + "6ee1358846c": 13225, + "uint256 fromBalance = _balances[from": 13226, + "b063c7d": 13227, + "0.4.25.sol": 13228, + "https://github.com/oraclize/ethereum-api/blob/b42146": 13229, + "digits;\\n while (temp != 0) {\\n digits++;\\n temp ": 13230, + "\\n * {decimals} you should overload it.\\n *\\n * ": 13231, + "string private _name;\\n\\n // Token symbol\\n string private _symbol": 13232, + "if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp ": 13233, + "e9360e8/oraclizeAPI_": 13234, + "Inspired by OraclizeAPI": 13235, + "198246239e9360e8/oraclizeAPI_": 13236, + "6ee1358846c198246239e9360e8/oraclizeAPI_": 13237, + "b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_": 13238, + "https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_": 13239, + "if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits": 13240, + "https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol": 13241, + "7f": 13242, + "Gobbl": 13243, + "O ": 13244, + "}.\\n *\\n * Requirements:\\n *\\n * - `": 13245, + "\\n\\n // ": 13246, + ", `": 13247, + "token\\n * ": 13248, + "\\n * of ": 13249, + "Content": 13250, + "address(uniswapV2Router": 13251, + "Off": 13252, + "IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata": 13253, + "s.\\n ": 13254, + "Balancer": 13255, + ") internal pure returns (bytes32": 13256, + "have the ": 13257, + "(_packedAddressData[owner": 13258, + "` and a `": 13259, + "storage to ": 13260, + " - 1 (": 13261, + "occur": 13262, + "tic as ": 13263, + ")\\n }\\n\\n // ": 13264, + ";\\r\\n require(": 13265, + " := div(": 13266, + "Rounding": 13267, + "autoBurn": 13268, + "Upgradeable.sol\"": 13269, + "target address ": 13270, + "Newton": 13271, + "% 10))": 13272, + "allowance(address(this), ": 13273, + "nCheckpoints ": 13274, + "_ownedTokensIndex": 13275, + "startTokenId + ": 13276, + "Distributor": 13277, + "complet": 13278, + "contracts.\\n */\\n function _baseURI": 13279, + "proofFlags": 13280, + "_tokenApprovals;\\n\\n // Mapping from owner to operator approval": 13281, + "underflow is ": 13282, + "skim": 13283, + "BITMASK_ADDRESS_DATA_ENTRY;\\n }\\n\\n /**\\n * Returns the ": 13284, + "effec": 13285, + ") public payable virtual override {\\n ": 13286, + "safeIncreaseAllowance": 13287, + "safeDecreaseAllowance": 13288, + "zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general ": 13289, + "in child contracts.\\n */\\n function _baseURI": 13290, + "Counter overflow is incredibly unrealistic as ": 13291, + "token has been burned": 13292, + ";\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol": 13293, + "IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.": 13294, + "(_packedAddressData[owner] ": 13295, + " - 1 (max value of ": 13296, + ".l": 13297, + ";\\n ": 13298, + "Art": 13299, + "_erc20": 13300, + "s: ": 13301, + "ving": 13302, + "init": 13303, + "\\n * ": 13304, + "of denominator": 13305, + "\\n * - ": 13306, + "value % 10))": 13307, + "with full ": 13308, + ");\\n }\\n\\n /**\\n * @dev Mint": 13309, + "paper": 13310, + "`amount` is the ": 13311, + "Unpaused": 13312, + "verification ": 13313, + "_checkOwner": 13314, + ") {\\n // Inspired by OraclizeAPI": 13315, + "''''": 13316, + "digits] = bytes1(uint8(48 + ": 13317, + "Metadata extension": 13318, + "while (value ": 13319, + "prod1 * ": 13320, + "denominator * inv": 13321, + "buffer[digits] = bytes1(uint8(48 + ": 13322, + "twos), ": 13323, + "` is zero, `tokenId` has been ": 13324, + "prod1 := sub(": 13325, + "pragma solidity ^0.8.0;\\r\\n\\r\\n": 13326, + "prod0 := ": 13327, + "COMM": 13328, + "256 division": 13329, + "512 bit ": 13330, + "mm, prod0": 13331, + "\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits": 13332, + "in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount": 13333, + "256 bits of the product": 13334, + "_burnCounter cannot be ": 13335, + "Emits a {Transfer} event": 13336, + "ce\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol": 13337, + "significant 256 bits of the product": 13338, + ";\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall": 13339, + "And also called ": 13340, + "(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI": 13341, + "implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol": 13342, + "with full precision": 13343, + "denominator * inv = 1 ": 13344, + "=\\\"": 13345, + "Tw": 13346, + "US": 13347, + "eed": 13348, + "xi": 13349, + "\\n ) ": 13350, + "address[] memory": 13351, + "ended to ": 13352, + "amount;\\n\\n emit Transfer": 13353, + "ing one ": 13354, + "byte(": 13355, + "stax": 13356, + "aft ": 13357, + "), 0x": 13358, + "if (nextTokenId ": 13359, + "/ /": 13360, + "principal": 13361, + "length = ": 13362, + ");\\n\\n emit ": 13363, + ".sol\\\";\\n\\n/**": 13364, + "_transferTokens": 13365, + "allowance is not ": 13366, + "constructor(address ": 13367, + ":= and": 13368, + ");\\n }\\n\\n /**\\n * ": 13369, + "unchecked {\\n uint256 ": 13370, + "\\n *\\n * Emits ": 13371, + "signature from ": 13372, + ") internal virtual {\\n _": 13373, + "STOR": 13374, + "packed ownership ": 13375, + "less than 2^256": 13376, + "toHexString(uint256(": 13377, + "uint256(value % 10))": 13378, + "Counter underflow is ": 13379, + "distribution": 13380, + ");\\n uint256 c = ": 13381, + "fees * ": 13382, + "parameter": 13383, + "blacklisted": 13384, + "too long": 13385, + "`sender` to `recipient` ": 13386, + "_approve(owner, spender, currentAllowance - amount": 13387, + "\"Address: insufficient balance\"": 13388, + "Revealed": 13389, + ") external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom": 13390, + "This is equivalent to `": 13391, + "overridden;\\n *\\n * NOTE: This ": 13392, + "spendAllowance(from, spender, amount": 13393, + "5` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This ": 13394, + "_transfer(owner, to, amount": 13395, + "would have to be 2**256": 13396, + "in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return ": 13397, + "buffer[digits] = bytes1(uint8(48 + uint256(value % 10))": 13398, + "in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom": 13399, + "implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits": 13400, + "Counter underflow is impossible ": 13401, + ")).": 13402, + ".amount": 13403, + "<< ": 13404, + "Wait": 13405, + "_M": 13406, + "_operations": 13407, + "`spender": 13408, + "b8": 13409, + "to.code.length": 13410, + ") + (": 13411, + "coin": 13412, + "is point": 13413, + "astic": 13414, + "sil": 13415, + "require(!": 13416, + "senderBalance ": 13417, + "contract to ": 13418, + "maxTX": 13419, + "The address to ": 13420, + ", address tokenB": 13421, + "`.\\n ": 13422, + "`.\\r\\n */\\r\\n function ": 13423, + "ONICAL": 13424, + ".\\n * To ": 13425, + "transfer from ": 13426, + "___": 13427, + "misc": 13428, + "\\n *\\n * ": 13429, + ") / ONE_20": 13430, + "`. (e.g. number of whitelist mint slots used": 13431, + "modular ": 13432, + "paused.\\n */\\n function _": 13433, + "_afterTokenTransfer(from, to, amount": 13434, + "(value);\\n require(": 13435, + "observ": 13436, + "tokenA, address tokenB": 13437, + "[owner].": 13438, + "ACL": 13439, + "0.6/": 13440, + "by the contract": 13441, + "keccak256('": 13442, + "token/ERC20/extensions/draft-": 13443, + "token.allowance(address(this), ": 13444, + "efficientHash": 13445, + "for `owner`. (e.g. number of whitelist mint slots used": 13446, + "uint[] memory amounts);\\n function ": 13447, + ".sol\\\";\\r\\nimport \\\"@openzeppelin/contracts/": 13448, + "Aux(address owner": 13449, + "Subscribe": 13450, + "CANONICAL": 13451, + "ary data for `owner`. (e.g. number of whitelist mint slots used": 13452, + "token.allowance(address(this), spender": 13453, + "();\\n }\\n\\n function ": 13454, + "){": 13455, + ",\\n * ": 13456, + ".\\r\\n * ": 13457, + "Ap": 13458, + "ES": 13459, + "Hen": 13460, + "TValues": 13461, + "_pric": 13462, + "_payload": 13463, + "`s` ": 13464, + "`TokenOwnership` ": 13465, + "master": 13466, + "were ": 13467, + "}\\n\\n function ": 13468, + "s := ": 13469, + "ough": 13470, + "unpackedOwnership": 13471, + "a = ": 13472, + "else ": 13473, + "eeth": 13474, + "by two": 13475, + "forge": 13476, + "balanceOf(owner": 13477, + "false`.\\n // - `nextInitialized` to `": 13478, + "IDex": 13479, + "amount in case of ": 13480, + ");\\n return (true, ": 13481, + "` and `to": 13482, + ".sol)\\n\\npragma solidity ^0.8.": 13483, + "lastChange": 13484, + "rewards ": 13485, + "one bit ": 13486, + "addr = ": 13487, + "}\\r\\n\"": 13488, + ">>= 8": 13489, + ") external;\\n\\n /**\\n * @dev Transfers ": 13490, + ") external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approv": 13491, + "} from \\\"@openzeppelin/contracts/": 13492, + "it is possible to ": 13493, + "_allTokensIndex": 13494, + "Revert if not ": 13495, + "twos ": 13496, + "under MIT licen": 13497, + "(\\r\\n address from": 13498, + "55555555": 13499, + "Lookup": 13500, + "`.\\n //\\n // ": 13501, + ") return (false, 0);\\n return (true, ": 13502, + "allowed SeaDrop": 13503, + "enough allowance is ": 13504, + "Updates:\\n // - `balance ": 13505, + "Does not update the allowance if the current ": 13506, + "(bytes32 hash, bytes memory ": 13507, + "downcasted) {\\n ": 13508, + "Finished": 13509, + ") {\\n _checkOwner();\\n _": 13510, + ", created from ": 13511, + "ing.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `": 13512, + ") public view virtual override returns (bool) {\\n return _operatorApproval": 13513, + "Origin": 13514, + "Might emit ": 13515, + "(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's ": 13516, + "(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in ": 13517, + "`TokenOwnership` struct ": 13518, + "lastChangeBlock": 13519, + "Revert if not enough allowance is ": 13520, + "`.\\n //\\n // We can directly ": 13521, + "Does not update the allowance if the current allowance": 13522, + "Revert if not enough allowance is available": 13523, + "Custom": 13524, + "Frequency": 13525, + "Nam": 13526, + "\\n uint256 public ": 13527, + ", ERC721": 13528, + "); ": 13529, + "exchange": 13530, + "uint256 new": 13531, + "magn": 13532, + "an infinite ": 13533, + " = 20": 13534, + ");\\n while (value ": 13535, + "antically ": 13536, + "onlyInitializ": 13537, + "clas": 13538, + "take ": 13539, + " is an ": 13540, + "log4": 13541, + "rais": 13542, + "hashPair": 13543, + "to, value": 13544, + ".\\n * And also called ": 13545, + "0 || ": 13546, + "\\n\\t\\t\\t": 13547, + "SellFees": 13548, + ");\\n value /= 10": 13549, + "updated on": 13550, + "script": 13551, + "27 to ": 13552, + ")\\n if (!": 13553, + "omic": 13554, + "type\\\":\\\"": 13555, + "2**k": 13556, + "Casted": 13557, + "have been allowed to ": 13558, + "your library ": 13559, + "equivalent to an infinite ": 13560, + "is the maximum `uint256": 13561, + "ANCE": 13562, + "Standard ": 13563, + "BySig": 13564, + ";\\n\\n // Mapping owner address to ": 13565, + "];\\n require(fromBalance ": 13566, + ". This is sem": 13567, + ",\\n uint256 value,\\n uint256 deadline": 13568, + "Governance": 13569, + "with an error ": 13570, + "utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev ": 13571, + "successful ": 13572, + "character": 13573, + "global_": 13574, + "0 ? string(abi.encodePacked(baseURI, ": 13575, + ".\\n // Counter overflow is incredibly unrealistic as ": 13576, + "minting.\\n * And also called ": 13577, + "@openzeppelin/contracts-0.6/": 13578, + "Does not update the allowance amount in case of ": 13579, + "maximum `uint256`, the ": 13580, + "square root of a ": 13581, + ".\\n */\\n function _checkOwner(": 13582, + "-= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10))": 13583, + "!= 0) {\\n digits ": 13584, + "Base URI for computing {tokenURI}. If set, the resulting URI for each\\n * ": 13585, + "transferFrom`. This is sem": 13586, + "Underflow of the sender's balance is impossible because we check for\\n // ownership above and the recipient's balance can't realistically overflow.\\n // Counter overflow is incredibly unrealistic as ": 13587, + "this extension's ": 13588, + "Throws if the sender is not the owner.\\n */\\n function _checkOwner(": 13589, + "allowance is not updated on": 13590, + "(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits": 13591, + ");\\n while (value != 0) {\\n digits ": 13592, + "antically equivalent to an infinite ": 13593, + ");\\n value /= 10;\\n }\\n return string(buffer": 13594, + "Does not update the allowance amount in case of infinite allowance": 13595, + "maximum `uint256`, the allowance is not updated on": 13596, + "-= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer": 13597, + "transferFrom`. This is semantically equivalent to an infinite ": 13598, + ");\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer": 13599, + "transferFrom`. This is semantically equivalent to an infinite approval": 13600, + " {\\n ": 13601, + "(bytes memory ": 13602, + "Nu": 13603, + "XX": 13604, + "_a": 13605, + "_swap": 13606, + "_36": 13607, + "ef": 13608, + "\\n * by default": 13609, + "ingle": 13610, + "\\\"}": 13611, + "address from": 13612, + "address payable": 13613, + "` if ": 13614, + ") {\\n assembly {\\n // ": 13615, + "lities ": 13616, + "Extra ": 13617, + "00000": 13618, + "length = 0": 13619, + "mbin": 13620, + ", address value": 13621, + " (i.e. ": 13622, + "INTER": 13623, + "] = false": 13624, + ";\\n if (": 13625, + "If `amount` is the ": 13626, + "address,string": 13627, + "rency": 13628, + "`. See {": 13629, + "isApprovedForAll(from, ": 13630, + "|| _": 13631, + "leafPo": 13632, + "` and `numberMinted": 13633, + "division by zero ": 13634, + "wants to ": 13635, + "infinity": 13636, + "ATURE_": 13637, + ".\\r\\n *\\r\\n * Requirements:\\r\\n *\\r\\n * - `": 13638, + ", // Toward ": 13639, + "DevelopmentFee": 13640, + "uint256) {\\n // Counter underflow is impossible ": 13641, + "`balance` and `numberMinted": 13642, + "}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApproval": 13643, + "\\\", \\\"Qm": 13644, + "leaves[": 13645, + "string memory baseURI = _baseURI();\\n return ": 13646, + "token will be the concatenation of the `baseURI` and the `tokenId`. Empty\\n * by default": 13647, + "Base URI for computing {tokenURI}. If set, the resulting URI for each\\n * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\\n * by default": 13648, + "If `amount` is the maximum `uint256`, the allowance is not updated on": 13649, + "}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator": 13650, + "(factory": 13651, + "/blob/": 13652, + "Action": 13653, + "Air": 13654, + "Available": 13655, + "Des": 13656, + "Lin": 13657, + "RValues": 13658, + "_previou": 13659, + "`extraData": 13660, + "`msb(a": 13661, + "ca": 13662, + "individ": 13663, + ", IERC165": 13664, + "ous ": 13665, + "oll": 13666, + "` function": 13667, + "of precision": 13668, + "- if ": 13669, + "privileg": 13670, + ". Compute the ": 13671, + "max-": 13672, + "with one bit ": 13673, + "Mints": 13674, + ";\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\\n * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\\n * by default": 13675, + "period ": 13676, + "idden": 13677, + "tokensSwapped": 13678, + "@notice": 13679, + ".\\n *\\n * Emits a {": 13680, + "interface of an ": 13681, + "; i < ": 13682, + "RoyaltyInfo ": 13683, + "_safeMint(to, quantity": 13684, + "getApproved(tokenId": 13685, + "curr]": 13686, + "based": 13687, + "`sender` is the ": 13688, + "isContract(target), \\\"Address: delegate ": 13689, + "KKKKKKKKKKKKKKKK": 13690, + "with a division by zero ": 13691, + "(data);\\n return verifyCallResultFromTarget": 13692, + "\\\");\\n unchecked {\\n ": 13693, + "modulo 2^256": 13694, + "purchase ": 13695, + "power of 2 ": 13696, + "2**(k/2": 13697, + "uint amountToken, uint amount": 13698, + "\\\"\\r\\n );\\r\\n ": 13699, + "Required interface of an ": 13700, + "mload(0x40": 13701, + "-std": 13702, + "\"// SPDX-License-Identifier: MIT\\n// ERC721A Contracts v4.": 13703, + "currentAllowance != type(uint256).max) {\\n require(": 13704, + "FACE_ID_": 13705, + "forge-std": 13706, + "with one bit of precision": 13707, + "(data);\\n return verifyCallResultFromTarget(target, ": 13708, + " can be ": 13709, + "\"re": 13710, + "(non-": 13711, + ".\\n // ": 13712, + "225": 13713, + "Cast ": 13714, + "Hal": 13715, + "wri": 13716, + "to.isContract": 13717, + "uint72": 13718, + "t in ": 13719, + "uint256) ": 13720, + "\\\"0x00": 13721, + "verse": 13722, + "str := sub(": 13723, + "ipf": 13724, + "FeeRecipient": 13725, + "who ": 13726, + "recipient != address(0), \\\"ERC20: ": 13727, + ", address approvedAddress": 13728, + "utch": 13729, + "Roles ": 13730, + "oldWallet": 13731, + "(_from, ": 13732, + "_mint(msg.sender, ": 13733, + "Delay ": 13734, + "() external view returns (bytes32": 13735, + ") internal virtual {\\n _mint": 13736, + "large ": 13737, + "check if ": 13738, + "product = ": 13739, + "oracle ": 13740, + " {\\n /**\\n * @dev Returns the amount of tokens ": 13741, + ",\\n bytes memory userData": 13742, + "_startTokenId();\\n ": 13743, + "################": 13744, + "owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to ": 13745, + "FEATURE_": 13746, + "executed ": 13747, + "_owners[tokenId] = to;\\n\\n emit Transfer": 13748, + " == address(0)) revert ": 13749, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (": 13750, + "approvedAddressSlot, address approvedAddress": 13751, + "getAmountsIn": 13752, + ") external onlyOwner {\\r\\n ": 13753, + "currentAllowance = allowance(owner, spender);\\n if (": 13754, + "unique. ": 13755, + "toHexString(value, length": 13756, + "packed = _packedOwnerships[": 13757, + "Already": 13758, + "s\\n mapping(address => mapping(address => bool)) private _operatorApprovals": 13759, + "The default value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * ": 13760, + "string memory baseURI = _baseURI();\\n return bytes(baseURI).length": 13761, + ":: ": 13762, + "\\\\n": 13763, + "jo": 13764, + "many ": 13765, + "s can be ": 13766, + ", ERC20": 13767, + "Inh": 13768, + "\\r\\n returns (": 13769, + "sender != address(0), \\\"ERC20: ": 13770, + "keLP": 13771, + ");\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner(": 13772, + "this contract": 13773, + "pret": 13774, + "emit a {Role": 13775, + "reverted\"": 13776, + " the first ": 13777, + ".\\n * @dev ": 13778, + "Sell ": 13779, + "current nonce ": 13780, + "\"@openzeppelin/contracts/utils/introspection/ERC165.sol\"": 13781, + "\\\\x01": 13782, + "unchecked {\\n if (": 13783, + ";\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev ": 13784, + "feature": 13785, + ");\\n _afterTokenTransfers": 13786, + "EnumerableSet ": 13787, + "deployed ": 13788, + ";\\r\\n emit ": 13789, + "\\r\\n /**\\r\\n * @notice ": 13790, + "guard": 13791, + ");\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev ": 13792, + "Address of ": 13793, + ", bytes32 indexed ": 13794, + "interfaceId == 0x": 13795, + "sqrt(uint256 a": 13796, + "Mask `": 13797, + "Whitelisted": 13798, + "system ": 13799, + "Library ": 13800, + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to ": 13801, + "`.\\n result := ": 13802, + ") internal virtual {\\n uint256 currentAllowance = allowance(owner, spender);\\n if (": 13803, + ") | _nextExtraData": 13804, + ",\\n uint256[] memory balances": 13805, + "May emit a {Role": 13806, + "(token, abi.encodeWithSelector(token.approve.selector, ": 13807, + "numCheckpoints": 13808, + "(from, address(0), tokenId, 1": 13809, + "` to the lower 160 bits, in case the upper bits somehow aren't clean.\\n ": 13810, + "minimal ": 13811, + " bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted ": 13812, + ");\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId": 13813, + ";\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to ": 13814, + ") {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev ": 13815, + "NukeLP": 13816, + ");\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev ": 13817, + ");\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner(": 13818, + ",0": 13819, + "59": 13820, + "SCRIP": 13821, + "_subtractedValue": 13822, + "ued": 13823, + "trusted ": 13824, + "length++;\\n temp ": 13825, + "mappings\"": 13826, + "ContractURI": 13827, + "roles[role].": 13828, + "_burnFee": 13829, + "reserve0, ": 13830, + "_setDefaultRoyalty": 13831, + "DelegateVotes": 13832, + "Updated(_": 13833, + "1000000": 13834, + "delegateBySig": 13835, + "LPBurn": 13836, + "\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0": 13837, + "TRANSFER": 13838, + "token/ERC20/extensions/ERC20Burnable": 13839, + "/// @solidity memory-safe-assembly\\n assembly {\\n ": 13840, + "launched": 13841, + "interfaces/IERC2981": 13842, + "QuantityExceeds": 13843, + ";\\n }\\n return toHexString(value, length": 13844, + "0.6.2": 13845, + "validat": 13846, + "Under": 13847, + "\\n * ": 13848, + ";\\n while (temp != 0) {\\n length++;\\n temp ": 13849, + "if (value == 0) {\\n return \\\"0x00": 13850, + "\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0": 13851, + "Pos++] : ": 13852, + ") internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner": 13853, + "(account, address(0), amount);\\n\\n _afterTokenTransfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(\\n address owner,\\n address spender,\\n uint256 amount\\n ": 13854, + "token\\n * by either {approve} or {setApprovalForAll": 13855, + "staxFee": 13856, + "(bytes32 hash, bytes memory signature": 13857, + "\"remappings\"": 13858, + ");\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(": 13859, + ") internal virtual {\\n uint256 currentAllowance = allowance(owner, spender);\\n if (currentAllowance != type(uint256).max) {\\n require(": 13860, + "if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0": 13861, + "if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp ": 13862, + "6f": 13863, + "NAL": 13864, + "lz": 13865, + "reach": 13866, + "enabl": 13867, + "in\\n // ": 13868, + "unpause": 13869, + ".\\n * ": 13870, + "ing the zero ": 13871, + ": this is ": 13872, + "s (`approved": 13873, + "The address ": 13874, + "Seed": 13875, + "burnFeeReceiver": 13876, + "Up(": 13877, + "buyFee": 13878, + "Counters for ": 13879, + "has no ": 13880, + ", address indexed account": 13881, + "() external view override returns (": 13882, + "safeMint(\\n address to": 13883, + ") internal virtual {\\n require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(to != address(0), \\\"ERC20: ": 13884, + "ownership slot": 13885, + "disables (`approved": 13886, + "\"Address: unable to send value, recipient may have ": 13887, + "stored by the contract": 13888, + "Weighted": 13889, + ">= amount, \\\"ERC20: insufficient allowance": 13890, + "multiply ": 13891, + ") <= sqrt(a": 13892, + ") <= a < ": 13893, + "(address addr) external returns (": 13894, + "counter._value": 13895, + "owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev ": 13896, + "destination ": 13897, + "(address registrant, address operator": 13898, + ");\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n ": 13899, + "present.\\n */\\n function remove(": 13900, + ") internal returns (bool) {\\n return _remove(": 13901, + "arbitrary address": 13902, + "flash loan ": 13903, + "SecondarySales": 13904, + "LOGIC": 13905, + ".\\n unchecked {\\n // Updates:\\n // - `balance ": 13906, + ") {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := ": 13907, + ") internal view returns (bool) {\\n return _contains(": 13908, + "Ethereum Signed Message:\\\\n": 13909, + "Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := ": 13910, + "is already open\"": 13911, + "_getCurrentSupply": 13912, + ") internal view returns (uint256) {\\n return _length(": 13913, + "_burn(tokenId, false": 13914, + "5` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `": 13915, + "(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer": 13916, + "_previoustaxFee": 13917, + "uint amountToken, uint amountETH": 13918, + ");\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner": 13919, + ";\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecim": 13920, + ");\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev ": 13921, + "Counters for Counters.Counter": 13922, + "\"Address: unable to send value, recipient may have reverted\"": 13923, + ") <= sqrt(a) < ": 13924, + ");\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp ": 13925, + ");\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev ": 13926, + "3f": 13927, + "6C": 13928, + "v1": 13929, + ", uint256[] memory ": 13930, + "func": 13931, + "query": 13932, + "==========": 13933, + ");\\n _transfer(from, to, amount": 13934, + ";\\n assembly {\\n ": 13935, + "(uint256 x": 13936, + "msg.sender, ": 13937, + "@param ": 13938, + "!= address(0)": 13939, + "modifi": 13940, + "allowlist": 13941, + "entry": 13942, + "changed": 13943, + ";\\n }\\n\\n function _": 13944, + "finish": 13945, + ") revert TransferCallerNotOwnerNorApproved": 13946, + "_getTValues": 13947, + "set._values[": 13948, + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../": 13949, + "2**64": 13950, + "_totalMinted": 13951, + "including the ": 13952, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata": 13953, + "amount exceeds balance\\\");\\n ": 13954, + "Cannot": 13955, + "rounding down": 13956, + "unique": 13957, + "Internal function to ": 13958, + "address owner = _msgSender();\\n uint256 ": 13959, + "located ": 13960, + "BITMASK_ADDRESS)\\n // ": 13961, + "_balances[account] = _balances[account": 13962, + "_CACHED_CHAIN_ID": 13963, + "requiring ": 13964, + "set._inner, bytes32(value": 13965, + "\\r\\n *\\r\\n * ": 13966, + "AddressSet storage set, address value": 13967, + "UintSet storage set, uint256 value": 13968, + "sorted": 13969, + "_afterTokenTransfers(address(0), to, startTokenId, quantity": 13970, + "dividendTracker": 13971, + "] = _packOwnershipData(\\n to": 13972, + "Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n ": 13973, + "address spender = _msgSender();\\n _": 13974, + "uint256 fromBalance = _balances[from];\\n require(fromBalance ": 13975, + "_tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping(address => mapping(address => bool)) private _operatorApprovals": 13976, + "spendAllowance(from, spender, amount);\\n _transfer(from, to, amount": 13977, + "getApproved(tokenId) == ": 13978, + "Histor": 13979, + "`.\\n *\\n * Requirements:\\n *\\n * - `from": 13980, + "`quantity` ": 13981, + "caus": 13982, + "c >= ": 13983, + "→ `": 13984, + "s them ": 13985, + "\\n * is the maximum `uint256": 13986, + "all of ": 13987, + "address payable ": 13988, + "\\n * ": 13989, + "ERC20Basic": 13990, + ".\\n *\\n * Might emit ": 13991, + "TransferHelper": 13992, + "overhead": 13993, + "} function": 13994, + "creation": 13995, + "0x40": 13996, + "URATION": 13997, + "will not ": 13998, + "returns (bool) {\\n return ": 13999, + ".\\n * Revert if not enough allowance is available": 14000, + "an {Approval} event.\\n */\\n function _": 14001, + "_getRValues": 14002, + "000000000000000000000000": 14003, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev ": 14004, + "currentAllowance >= amount, \\\"ERC20: insufficient allowance": 14005, + " (when the result is negative": 14006, + "StartTime": 14007, + "move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function ": 14008, + "ONE_18": 14009, + "== 0) {\\n return 0;\\n ": 14010, + "MAX_MINT_": 14011, + "address owner = _msgSender();\\n _approve(owner, spender, ": 14012, + "╬╬╬╬╬╬╬╬": 14013, + ") internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate ": 14014, + "}.\\n *\\n * NOTE: Does not update the allowance if the current allowance": 14015, + ";\\n\\nimport './": 14016, + "Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} ": 14017, + "Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function ": 14018, + "rely on ": 14019, + "Map storage ": 14020, + "Wrappers over ": 14021, + ") internal virtual {}\\n\\n /**\\n * @dev Hook that is called after any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * has been transferred to `to`.\\n * - when `from` is zero, `amount` tokens have been minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n ": 14022, + "if (nextTokenId != ": 14023, + "` and `to` cannot be the zero address.\\n * - `": 14024, + ") external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to": 14025, + ") external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero ": 14026, + "SCRIPTION": 14027, + "Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {}\\n\\n /**\\n * @dev Hook that is called after any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * has been transferred to `to`.\\n * - when `from` is zero, `amount` tokens have been minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n ": 14028, + "address spender = _msgSender();\\n _spendAllowance(from, spender, amount);\\n _transfer(from, to, amount": 14029, + "`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `": 14030, + "\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `": 14031, + ".\\n *\\n * Might emit an {Approval} event.\\n */\\n function _": 14032, + ".\\n * Revert if not enough allowance is available.\\n *\\n * Might emit an {Approval} event.\\n */\\n function _": 14033, + "}.\\n *\\n * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `": 14034, + "Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator": 14035, + ") external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId": 14036, + ".\\n * Revert if not enough allowance is available.\\n *\\n * Might emit an {Approval} event.\\n */\\n function _spendAllowance": 14037, + " bytes": 14038, + "49": 14039, + "4a": 14040, + "Vesting": 14041, + "v` ": 14042, + "•´": 14043, + "\\n }\\n }\\n\\n /**\\n * @dev ": 14044, + "tier-": 14045, + ", add(": 14046, + "tokenIn": 14047, + "end ": 14048, + "isOwner": 14049, + "amountReceived": 14050, + "\\n\\n // The ": 14051, + ") external pure returns (": 14052, + "approve}.\\n *\\n * NOTE: ": 14053, + "tokens in ": 14054, + "roleMember": 14055, + "ed by {": 14056, + "implement the ": 14057, + "line-": 14058, + "emption": 14059, + "Rewards(": 14060, + ";\\n }\\n\\n /// @dev ": 14061, + "Errors": 14062, + "\\n * `transferFrom`. This is semantically equivalent to an infinite approval": 14063, + "`.\\n *\\n * Does not update the allowance amount in case of infinite allowance": 14064, + "https://eips.ethereum.org/EIPS/eip-2": 14065, + ";\\n }\\n if (": 14066, + "exists(uint256 tokenId": 14067, + "we're ": 14068, + ");\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value": 14069, + "token/ERC20/ERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./": 14070, + "super._beforeTokenTransfer": 14071, + "releaseTime": 14072, + "`. This value ": 14073, + "from` must have a balance of at least `amount`.\\n * - the caller must have allowance for ": 14074, + "TxnAmount": 14075, + ";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer": 14076, + " <= a, errorMessage": 14077, + "If `to` refers to a smart contract, it must implement\\n * {": 14078, + ">>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecim": 14079, + ",\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ": 14080, + "prettier-": 14081, + "disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ": 14082, + ");\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecim": 14083, + "}.\\n *\\n * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n * - the caller must have allowance for ": 14084, + "`.\\n *\\n * Does not update the allowance amount in case of infinite allowance.\\n * Revert if not enough allowance is available.\\n *\\n * Might emit an {Approval} event.\\n */\\n function _spendAllowance": 14085, + ";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecim": 14086, + "prettier-ignore": 14087, + "-based": 14088, + "1 << (": 14089, + "3a": 14090, + "364": 14091, + "E8": 14092, + "^ b": 14093, + "_must": 14094, + "s_": 14095, + "address\"": 14096, + "to use ": 14097, + "a ^ b": 14098, + "TokenIn": 14099, + "s.add(": 14100, + "minut": 14101, + ";\\npragma ": 14102, + "INon": 14103, + ",\\n uint256 b": 14104, + "// See: ": 14105, + "Total ": 14106, + "emit OwnershipTransferred(": 14107, + "role that ": 14108, + ") {\\n if (": 14109, + "\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\"": 14110, + ".\\n return ": 14111, + "Enumerable is ": 14112, + "27 or ": 14113, + "depending ": 14114, + "allowedNft": 14115, + "Debt": 14116, + "(1 << _": 14117, + "string,uint,": 14118, + "slot) internal pure returns (": 14119, + "ENS": 14120, + "with the registry ": 14121, + "(bytes32 slot) internal pure returns (": 14122, + "`value` located ": 14123, + "_maxWalletToken": 14124, + ".\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, `from`'s ": 14125, + "_approve(owner, spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20": 14126, + "] = _HEX_SYMBOLS": 14127, + "originated ": 14128, + "0 ? 0 : ": 14129, + "``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to": 14130, + "negative ": 14131, + "` with member ": 14132, + "to` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function ": 14133, + "security/Pausable": 14134, + "2**(log2(a": 14135, + "on-chain ": 14136, + "HEX_SYMBOLS = \\\"0123456789abcdef": 14137, + "returndatasize())": 14138, + "`.\\n _packedAddressData": 14139, + "_balances[to] += 1;\\n ": 14140, + "_previousredisFee": 14141, + "numberOfTokens": 14142, + "`hash` ": 14143, + "xCvx": 14144, + "ERC721Metadata: URI ": 14145, + "at `slot": 14146, + "result < value ? 1 : 0": 14147, + ", address[] calldata path, address to, ": 14148, + "seriesSum += ": 14149, + "Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ": 14150, + "`.\\n *\\n * This internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event": 14151, + "cheaper than ": 14152, + "/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function ": 14153, + "_approve(owner, spender, currentAllowance - amount);\\n }\\n }\\n }\\n\\n /**\\n * @dev ": 14154, + "If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval": 14155, + "max-line-": 14156, + "] = _packOwnershipData(\\n to,\\n _": 14157, + "approve}.\\n *\\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval": 14158, + ";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i": 14159, + "27 or 28": 14160, + "`value` located at `slot": 14161, + "_approve(owner, spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n * - the caller must have allowance for ": 14162, + "` with member `value` located at `slot": 14163, + ", address[] calldata path, address to, uint deadline": 14164, + "max-line-length": 14165, + "(i.e. `": 14166, + "^^": 14167, + "len": 14168, + "sent to ": 14169, + "s should be ": 14170, + "combin": 14171, + ".\\n */\\n function recover": 14172, + "anti": 14173, + "32 bytes ": 14174, + "), true": 14175, + ");\\n\\n _afterTokenTransfer": 14176, + ").transfer": 14177, + "RoleGrant": 14178, + "constructor(\\n ": 14179, + "any token transfer": 14180, + "96(": 14181, + "removeAllFee": 14182, + "me/": 14183, + "/**\\n * @notice Calculates ": 14184, + "Recovery": 14185, + ";\\n\\n /**\\n * @dev Initializes the contract ": 14186, + "RARE": 14187, + "\"SafeMath: modulo by ": 14188, + "operation for ": 14189, + "this function is ": 14190, + "structs/": 14191, + "contains ": 14192, + "super._transfer": 14193, + "getApprovedSlotAndAddress": 14194, + "offset ": 14195, + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount": 14196, + "managed ": 14197, + "0.7.": 14198, + "(hash, v, r, s": 14199, + "%%%%%%%%": 14200, + "can then be ": 14201, + "(from, to, amount);\\n\\n _afterTokenTransfer(from, to, amount": 14202, + "(from, to, amount);\\n\\n uint256 fromBalance = _balances[from];\\n require(fromBalance ": 14203, + "address(0xdead": 14204, + "r` and `s` ": 14205, + "fixed point number": 14206, + "Overload of {ECDSA-recover": 14207, + "_OFFSET": 14208, + "on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `": 14209, + "nonces[owner": 14210, + "\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - amount);\\n }\\n }\\n }\\n\\n /**\\n * @dev ": 14211, + "Required interface of an ERC721 ": 14212, + "(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage": 14213, + "`.\\n *\\n * This internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount": 14214, + "/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div": 14215, + "approve}.\\n *\\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount": 14216, + "`.\\n *\\n * This internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n */\\n function _transfer": 14217, + "),\\n ": 14218, + ",\\n // ": 14219, + ":\\n * ": 14220, + "AF": 14221, + "Gauge": 14222, + "_current": 14223, + "a\\n * ": 14224, + "ring the ": 14225, + "ted by ": 14226, + ", rounded down": 14227, + "oughtEarly": 14228, + "///": 14229, + "ToMint": 14230, + "mail": 14231, + "stack": 14232, + "side": 14233, + ".\\n */\\n function mulDiv": 14234, + ";\\n }\\n }\\n\\n function ": 14235, + "sender` and `": 14236, + " is a ": 14237, + ";\\n\\n uint256 public ": 14238, + "params": 14239, + "0x00000000000000000000000000000000": 14240, + " * 10**": 14241, + "result of a ": 14242, + "RoleRevoked(": 14243, + "data bytes ": 14244, + "= _currentIndex": 14245, + ") public virtual {\\n ": 14246, + "\\\");\\n\\n _": 14247, + ") internal view virtual override returns (": 14248, + "Set _inner": 14249, + "_taxFeeOnBuy": 14250, + "projects[": 14251, + "standardiz": 14252, + "Address of the ": 14253, + "each step": 14254, + "RoleAdminChanged(": 14255, + "`, it is the ": 14256, + "\\n\\t */": 14257, + "the `Transfer` ": 14258, + "twos)\\n\\n // ": 14259, + "set._inner, index": 14260, + "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM": 14261, + "at(set._inner, index": 14262, + "result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n ": 14263, + "as part of a ": 14264, + ");\\n }\\n if (": 14265, + "manualSwap": 14266, + "present.\\n */\\n function add(": 14267, + ") internal returns (bool) {\\n return _add(": 14268, + "the contract call": 14269, + " THIS": 14270, + "in the set. O(1).\\n */\\n function contains(": 14271, + "_approve(address(0), tokenId);\\n\\n ": 14272, + "Set {\\n Set _inner": 14273, + "Returns true if the value is in the set. O(1).\\n */\\n function contains(": 14274, + "Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(": 14275, + ";\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(": 14276, + "account that originated ": 14277, + ");\\n }\\n\\n /**\\n * @dev Returns the number of values ": 14278, + "\"trading is already open\"": 14279, + "by twos.\\n ": 14280, + "infinity\\n ": 14281, + "- if using `": 14282, + "`sender` is the account that originated ": 14283, + "The default value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5.0": 14284, + ", address indexed account, address indexed sender": 14285, + ") internal virtual {\\n require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(to != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer": 14286, + ") internal view returns (uint256) {\\n return _length(set._inner": 14287, + "if (nextTokenId != _currentIndex": 14288, + "emit OwnershipTransferred(_owner": 14289, + "to` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address to, uint256 amount": 14290, + "Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to": 14291, + "RoleGranted(": 14292, + "any token transfer. This includes ": 14293, + "\"SafeMath: modulo by zero\"": 14294, + "standardized ": 14295, + "Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(": 14296, + "`sender` is the account that originated the contract call": 14297, + " C": 14298, + " ^ ": 14299, + "(address,address,": 14300, + "1\\\"": 14301, + "BURN": 14302, + "\\n* ": 14303, + "\\npragma solidity >=": 14304, + "s for the ": 14305, + "inel": 14306, + "active ": 14307, + "ory": 14308, + "attribu": 14309, + "tokens/": 14310, + ".swap": 14311, + "public immutable ": 14312, + "newVotes": 14313, + "0.9": 14314, + "_transfer:: ": 14315, + "_approve(address(this), ": 14316, + "Minimum": 14317, + " for a ": 14318, + " == 0) {\\n ": 14319, + "change the ": 14320, + ") external;\\r\\n": 14321, + ";\\n // ": 14322, + "temp, ": 14323, + ");\\n function get": 14324, + "tradingEnabled": 14325, + "UNCOMM": 14326, + "calling {": 14327, + ") public virtual override returns (bool) {\\n address spender = _msgSender();\\n _spendAllowance(from, spender, amount);\\n _transfer(from, to, amount": 14328, + "\\n // =============================================================\\n\\n /**\\n * @dev Returns the ": 14329, + "VERY ": 14330, + "chain id ": 14331, + "Overflows are ": 14332, + "necessary": 14333, + "order of the ": 14334, + "(x, y": 14335, + "░░░░░░░░░░░░░░░░": 14336, + "this is by ": 14337, + "codeHashes": 14338, + "UniswapV3": 14339, + " to be transferred.\\n * ": 14340, + "_setupRole": 14341, + "address that signed ": 14342, + "IERC20Permit-": 14343, + "` in packed address data.\\n uint256 private constant _": 14344, + ">= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n unchecked {\\n _balances[from] = fromBalance - amount": 14345, + "bit in packed ownership.\\n uint256 private constant _": 14346, + "compliant contract.\\n */\\ninterface IERC721": 14347, + "Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved": 14348, + "Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721": 14349, + " ✓": 14350, + ".push": 14351, + "DS": 14352, + "Pt": 14353, + "Web": 14354, + "_QU": 14355, + "`\\n // ": 14356, + "cd": 14357, + "s!": 14358, + "tLiquidity": 14359, + "\\n returns (": 14360, + "on\\r\\n * ": 14361, + "uint);\\n\\n function ": 14362, + ") signatures": 14363, + "tokenomic": 14364, + "address can then be ": 14365, + "a hashed ": 14366, + "` EVM ": 14367, + "of its ": 14368, + "strategy ": 14369, + ": it is possible to ": 14370, + "eep": 14371, + "be too long": 14372, + " to arbitrary address": 14373, + "by requi": 14374, + "swap and ": 14375, + "hash`) ": 14376, + "in the lower": 14377, + "feeRecipient": 14378, + "Pools ": 14379, + "from, tokenId, _data": 14380, + ", and the `": 14381, + "non-hashed ": 14382, + "ENT THIS": 14383, + "`.\\n *\\n * `sender` is the account that originated the contract call": 14384, + "then calling {": 14385, + "no longer ": 14386, + "recover to arbitrary address": 14387, + "either 27 or 28": 14388, + "ing a hash of the ": 14389, + "message (`": 14390, + "message (which ": 14391, + "this function reject": 14392, + "A safe ": 14393, + "_currentIndex = ": 14394, + " to be secure": 14395, + "_ be the ": 14396, + "craft ": 14397, + "opcode allows for ": 14398, + "IMPORTANT: UNCOMM": 14399, + "Paramet": 14400, + "checkpoints[account": 14401, + "state-": 14402, + "data. A safe ": 14403, + "hash operation for ": 14404, + "way to ensure": 14405, + ")\\n\\n // ": 14406, + ");\\n\\n /**\\n * @dev Emitted when `account` is ": 14407, + "normal ": 14408, + "ecrecover` EVM ": 14409, + "es for non-hashed ": 14410, + "used for verification ": 14411, + " LATER": 14412, + "Enabled ": 14413, + "``from``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom": 14414, + "VRF ": 14415, + ",\\r\\n address to,\\r\\n ": 14416, + "explicitly ": 14417, + "When `from` and `to` are both non-zero, ``from``'s ": 14418, + "toEthSignedMessageHash} on ": 14419, + "Handler": 14420, + "original message (which ": 14421, + "=-=-=-=-": 14422, + "_approve(owner, spender, currentAllowance - subtractedValue);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves `amount` of tokens from ": 14423, + "malleable (non-": 14424, + "value to be in the lower": 14425, + "value to be either 27 or 28": 14426, + "} that receives the `v": 14427, + "_Available since v3.4._": 14428, + "bytes32[] calldata proof": 14429, + "Settings": 14430, + "half order, and the `": 14431, + "bytes32 indexed role, address indexed account, address indexed sender": 14432, + "verification to be secure": 14433, + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, ": 14434, + "), and then calling {": 14435, + "addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n uint256 ": 14436, + "bility ": 14437, + "receiving a hash of the ": 14438, + "_transfer(owner, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-": 14439, + "`s` value to be in the lower": 14440, + "(\\r\\n address from,\\r\\n address to,\\r\\n uint256 ": 14441, + "_safeMint(to, quantity, ''": 14442, + "unique) signatures": 14443, + "s them by requi": 14444, + "v` value to be either 27 or 28": 14445, + "_must_ be the ": 14446, + "`hash` _must_ be the ": 14447, + "_approve(owner, spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``from``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom": 14448, + "r` and `s` signature fields separately": 14449, + "ring the `s` value to be in the lower": 14450, + "result of a hash operation for ": 14451, + ") internal virtual {\\n require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(to != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, amount);\\n\\n uint256 fromBalance = _balances[from];\\n require(fromBalance ": 14452, + "VERY IMPORTANT: UNCOMM": 14453, + "this is by receiving a hash of the ": 14454, + "address that signed a hashed ": 14455, + "address can then be used for verification ": 14456, + ": it is possible to craft ": 14457, + "be too long), and then calling {": 14458, + "ENT THIS LATER": 14459, + "recover to arbitrary addresses for non-hashed ": 14460, + "message (`hash`) ": 14461, + "this function rejects them by requi": 14462, + "opcode allows for malleable (non-": 14463, + "data. A safe way to ensure": 14464, + "ecrecover` EVM opcode allows for malleable (non-": 14465, + "toEthSignedMessageHash} on it": 14466, + "original message (which may ": 14467, + "half order, and the `v` value to be either 27 or 28": 14468, + "verification to be secure: it is possible to craft ": 14469, + "`hash` _must_ be the result of a hash operation for ": 14470, + "VERY IMPORTANT: UNCOMMENT THIS LATER": 14471, + "this is by receiving a hash of the original message (which may ": 14472, + "address that signed a hashed message (`hash`) ": 14473, + "be too long), and then calling {toEthSignedMessageHash} on it": 14474, + "recover to arbitrary addresses for non-hashed data. A safe way to ensure": 14475, + "this function rejects them by requiring the `s` value to be in the lower": 14476, + "ecrecover` EVM opcode allows for malleable (non-unique) signatures": 14477, + "verification to be secure: it is possible to craft signatures ": 14478, + ")\\n * ": 14479, + "));\\n }\\n}\\n\"": 14480, + "/I": 14481, + "_last": 14482, + "fur": 14483, + "}.\\n */\\n function _": 14484, + "e for ": 14485, + "s if ": 14486, + "/**\\n\\t * ": 14487, + "Success": 14488, + "\\r\\n// ": 14489, + ") external onlyOwner {\\n require(": 14490, + ", uint256 _value": 14491, + "credit": 14492, + "Without": 14493, + ") {\\n uint256 ": 14494, + ") internal pure returns (bytes32) {\\n return ": 14495, + "is not active": 14496, + "pair of ": 14497, + "stop ": 14498, + "account had": 14499, + "rounds ": 14500, + "Type ": 14501, + "initialETHBalance": 14502, + "protocolSwapFeePercentage": 14503, + "copi": 14504, + "(address(0), to, tokenId": 14505, + "_PRIC": 14506, + "uint256,uint256,": 14507, + "rewardsToken": 14508, + "_EXP": 14509, + "[from]": 14510, + "otherwise\\n * ": 14511, + "Request ": 14512, + "multiplying ": 14513, + "Fungible": 14514, + "& _BITMASK_ADDRESS_DATA_ENTRY;\\n }\\n\\n /**\\n * Returns the ": 14515, + "amountToLiquify": 14516, + "_CACHED_DOMAIN_SEPARATOR": 14517, + ") public virtual override returns (bool) {\\n address owner = _msgSender();\\n _transfer(owner, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-": 14518, + "restoreAllFee": 14519, + "split": 14520, + "IGH": 14521, + "\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n": 14522, + "(proof, ": 14523, + "Delay enabled": 14524, + ") internal virtual {\\n uint256 currentAllowance = allowance(owner, spender);\\n if (currentAllowance != type(uint256).max) {\\n require(currentAllowance >= amount, \\\"ERC20: insufficient allowance": 14525, + "] = _HEX_SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer": 14526, + "address can then be used for verification purposes": 14527, + ") internal virtual {\\n uint256 currentAllowance = allowance(owner, spender);\\n if (currentAllowance != type(uint256).max) {\\n require(currentAllowance >= amount, \\\"ERC20: insufficient allowance\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - amount);\\n }\\n }\\n }\\n\\n /**\\n * @dev ": 14528, + " post": 14529, + "\"erc721a/contracts/": 14530, + "<= _": 14531, + "_00": 14532, + "a'": 14533, + "a,\\n uint256 b": 14534, + "ther": 14535, + "thing": 14536, + "the same ": 14537, + "amt": 14538, + ".\\n */\\n function set": 14539, + ", uint256 tokenId": 14540, + "istanbul": 14541, + "override this function": 14542, + "Size ": 14543, + "Wallets": 14544, + "_approve(to, tokenId": 14545, + "https://eth": 14546, + "nextSlot": 14547, + ", _BITMASK_ADDRESS)\\n // ": 14548, + "apply ": 14549, + "NOT ": 14550, + "() external onlyOwner {\\n ": 14551, + "keyHash": 14552, + "LOAD": 14553, + "SeaDropToken": 14554, + "(\\n uint256 a,\\n uint256 b": 14555, + "Manager ": 14556, + "role, account, _msgSender()": 14557, + "utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev ": 14558, + "codeHashes ": 14559, + "allowance(owner, spender) + ": 14560, + "depositor": 14561, + "`value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens ": 14562, + "Coordinator": 14563, + "exposed": 14564, + "(_packedAddressData[owner] >> _": 14565, + "` with member `value` located at `slot`.\\n */\\n function get": 14566, + "approve}.\\n *\\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n ": 14567, + "The default value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5.05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `": 14568, + "to` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address to, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _transfer(owner, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-": 14569, + ") public virtual override returns (bool) {\\n address spender = _msgSender();\\n _spendAllowance(from, spender, amount);\\n _transfer(from, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, ": 14570, + "to` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address to, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _transfer(owner, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n ": 14571, + "!!": 14572, + "\"P": 14573, + "Pause": 14574, + "_id": 14575, + "bin": 14576, + "c2": 14577, + "slo": 14578, + "weth": 14579, + "\\n/// @author ": 14580, + "\\n view": 14581, + "ermin": 14582, + "trusted": 14583, + "ed or ": 14584, + "amount = ": 14585, + "is lo": 14586, + "Id, ": 14587, + "convert": 14588, + "ableAmount": 14589, + "\\r\\n uint256 ": 14590, + ");\\n }\\n\\n /**\\n * @dev Approve ": 14591, + "mapping(bytes32 => ": 14592, + "ample ": 14593, + "preview": 14594, + "allowing ": 14595, + "ected": 14596, + "encodeWithSelector": 14597, + "Maximum": 14598, + "Ownable, ": 14599, + ");\\r\\n }\\r\\n }\\r\\n": 14600, + "rence": 14601, + ");\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to": 14602, + "];\\n if (": 14603, + "`spender` based on ": 14604, + "$$ |": 14605, + " to be minted": 14606, + "revokeRole(role, account);\\n }\\n\\n /**\\n * @dev ": 14607, + "Assum": 14608, + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\"": 14609, + "[to] += ": 14610, + "State.": 14611, + "short-": 14612, + "startTokenId = _currentIndex": 14613, + "timelock_address": 14614, + "Multiple": 14615, + "counter._value = ": 14616, + "\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.13": 14617, + "`,\\n * `": 14618, + "never be ": 14619, + "community": 14620, + "nominal": 14621, + "experimental ": 14622, + "operator-filter-registry/src/": 14623, + "OpenZeppelin Contracts guidelines: functions revert\\n * instead returning `false` on failure. This behavior is nonetheless\\n * conventional and does not conflict with the expectations of ERC20\\n * applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping(address => uint256) private _balances;\\n\\n mapping(address => mapping(address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The default value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5.05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `": 14624, + "Interest": 14625, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\"": 14626, + ";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = _HEX_SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer": 14627, + "(from, to, amount);\\n\\n _afterTokenTransfer(from, to, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n ": 14628, + "swap and pop": 14629, + "`value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom": 14630, + "\"@openzeppelin/contracts-upgradeable/": 14631, + "(n": 14632, + "));\\n\\n ": 14633, + ".current": 14634, + "04": 14635, + "GE": 14636, + "IB": 14637, + "Stuck": 14638, + "made": 14639, + "tosh": 14640, + "\\n * @param to ": 14641, + "an account ": 14642, + "ERC721-": 14643, + "maxBuyAmount": 14644, + "token already minted": 14645, + "balances, ": 14646, + "with https://": 14647, + "role. ": 14648, + "Into": 14649, + "starting": 14650, + ";\\n\\n/**\\n * @dev Interface ": 14651, + "st if ": 14652, + "grantRole(role, account);\\n }\\n\\n /**\\n * @dev ": 14653, + ", _amount": 14654, + "(address owner) internal view returns (uint256) {\\n return ": 14655, + "(address owner,address ": 14656, + ");\\r\\n\\r\\n /**\\r\\n * @dev ": 14657, + "ICIENT": 14658, + ");\\n\\n // Overflows are ": 14659, + "web3": 14660, + "being zero, ": 14661, + "restric": 14662, + "allowance for `spender` based on ": 14663, + "make sure ": 14664, + "mapping(address => uint256) public ": 14665, + "quantity == 0) revert Mint": 14666, + "Remove ": 14667, + ",uint256 value": 14668, + "Transfer Delay enabled": 14669, + "shouldn't ": 14670, + "dstRepNum": 14671, + ");\\n }\\n\\n": 14672, + "`owner` s allowance for `spender` based on ": 14673, + "RRRRRRRR": 14674, + "size := extcodesize": 14675, + ") | (": 14676, + "BitMap": 14677, + "(address(0), to, startTokenId, quantity);\\n\\n // Overflows are ": 14678, + "\\tuint256 ": 14679, + "r := shr(": 14680, + "_verifyCallResult(success, returndata, errorMessage": 14681, + "spent `amount": 14682, + "Updates `owner` s allowance for `spender` based on ": 14683, + "receiver interface": 14684, + "remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting ": 14685, + "% total supply.\"": 14686, + "UFFICIENT": 14687, + "ollar": 14688, + "with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function try": 14689, + "func-name-mixedcase": 14690, + "\\n }\\n }\\n\\n /**\\n * @dev Returns an `": 14691, + "_transfer:: Transfer Delay enabled": 14692, + ") internal virtual {\\n require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(to != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, amount);\\n\\n uint256 fromBalance = _balances[from];\\n require(fromBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n unchecked {\\n _balances[from] = fromBalance - amount": 14693, + "quantity == 0) revert MintZeroQuantity": 14694, + "_transfer:: Transfer Delay enabled. ": 14695, + "(uint8 ": 14696, + "TOTAL": 14697, + "\\n * half order, and the `v` value to be either 27 or 28": 14698, + "\\n * this is by receiving a hash of the original message (which may ": 14699, + "stETH": 14700, + "Address.": 14701, + "value in the ": 14702, + "contract from ": 14703, + "uplic": 14704, + ");\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover": 14705, + "IPool": 14706, + "lastvalue": 14707, + ";\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual ": 14708, + "updateMax": 14709, + "the\\n * verification to be secure: it is possible to craft signatures ": 14710, + "Dep": 14711, + "renounceRole(bytes32 role, address account": 14712, + "permit(\\n address owner,\\n address spender": 14713, + "_marketingWallet": 14714, + "higher than ": 14715, + "\\n */\\nabstract contract ERC20": 14716, + "over a ": 14717, + ".\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for ": 14718, + "mapping (address => bool": 14719, + "iteList": 14720, + "with\\n * `signature": 14721, + "enableTrading": 14722, + "that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure": 14723, + "_baseTokenURI": 14724, + "ERC721AQueryable-": 14725, + "emergency ": 14726, + "fillRandom": 14727, + "Common": 14728, + "String operations.\\n */\\nlibrary Strings {\\n bytes16 private constant _HEX_SYMBOLS = \\\"0123456789abcdef": 14729, + "\"// SPDX-License-Identifier: MIT\\npragma solidity 0.6.11": 14730, + "currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - subtractedValue);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves `amount` of tokens from ": 14731, + "safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes calldata data\\n ": 14732, + ".\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures": 14733, + " to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function ": 14734, + "Step": 14735, + "downcasted) {\\n downcasted = int": 14736, + " bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int": 14737, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\"": 14738, + "overhead for ": 14739, + "Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {}\\n\\n /**\\n * @dev Hook that is called after any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * has been transferred to `to`.\\n * - when `from` is zero, `amount` tokens have been minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {}\\n}\\n\"": 14740, + ":\\n * this function rejects them by requiring the `s` value to be in the lower": 14741, + "Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev ": 14742, + "address that signed a hashed message (`hash`) with\\n * `signature": 14743, + "otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it": 14744, + "address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures": 14745, + "to` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address to, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _transfer(owner, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``from``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom": 14746, + "Updates `owner` s allowance for `spender` based on spent `amount": 14747, + "\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for ": 14748, + "\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it": 14749, + "the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure": 14750, + ":\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for ": 14751, + "address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for ": 14752, + "the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it": 14753, + "address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it": 14754, + "(@": 14755, + "2;\\n }\\n if (value >> ": 14756, + "4;\\n result += ": 14757, + "4;\\n }\\n if (value >> ": 14758, + "8;\\n result += ": 14759, + "8;\\n }\\n if (value >> ": 14760, + "Bal": 14761, + "Mis": 14762, + "ts": 14763, + "\\n pure": 14764, + "addressData": 14765, + "\\\",\\n ": 14766, + "32 > 0) {\\n value >>= ": 14767, + "set_": 14768, + "\\n * - with https://": 14769, + "16;\\n }\\n if (value >> ": 14770, + "16 > 0) {\\n value >>= ": 14771, + "(uint256 indexed ": 14772, + "token g": 14773, + " is also ": 14774, + "payees": 14775, + ";\\n uint256 ": 14776, + "64 > 0) {\\n value >>= ": 14777, + " == owner || ": 14778, + "_SUB": 14779, + "UniswapV2Library.": 14780, + "genesis": 14781, + "128;\\n result += ": 14782, + ";\\n\\n if (": 14783, + "uint8 private constant _": 14784, + "keyIndex": 14785, + "swapExactTokensForTokens": 14786, + "if (!_is": 14787, + "tokenURI(uint256 tokenId) public view virtual override returns (": 14788, + "\"Address: call to non-contract\"": 14789, + "compromis": 14790, + "ethForMarketing": 14791, + "relev": 14792, + " > 0) {\\n value >>= 128;\\n result += ": 14793, + "getAmountIn": 14794, + "Immut": 14795, + "\\u003c= ": 14796, + ")\\r\\n external": 14797, + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2": 14798, + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10": 14799, + "_redisFeeOnBuy": 14800, + " > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base ": 14801, + "json": 14802, + "FilterOperator": 14803, + "bytes32 private immutable _": 14804, + "\\\",\\\"type\\\":\\\"": 14805, + "Address for address;\\n using ": 14806, + ">> 128 > 0) {\\n value >>= 128;\\n result += ": 14807, + "32;\\n result += 32": 14808, + "64;\\n result += 64": 14809, + "(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += ": 14810, + ".startTimestamp = uint64(": 14811, + "Wrappers over Solidity's ": 14812, + "ERC721Metadata: URI query for nonexistent token": 14813, + "result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base ": 14814, + "`\\n // → `": 14815, + "from, tokenId, _data) returns (": 14816, + "experimental ABIEncoderV2": 14817, + "16 > 0) {\\n value >>= 16;\\n result += ": 14818, + "_SUBSCRIPTION": 14819, + "#eth_sign": 14820, + "() internal view returns (": 14821, + ".'": 14822, + "Will ": 14823, + "_start": 14824, + "_uri": 14825, + "snapshot ": 14826, + "})": 14827, + ") returns (bool) {\\n ": 14828, + "\\r\\n */\\r\\n": 14829, + "to provide ": 14830, + "strategy": 14831, + " = 3": 14832, + "contractURI": 14833, + " to implement ": 14834, + "(uint256 _projectId": 14835, + "token holder ": 14836, + "msg.sender != ": 14837, + "Balance(": 14838, + "name\\\":\\\"": 14839, + "MintZeroQuantity": 14840, + "\\n {\\n ": 14841, + "Internal": 14842, + ",\\n address tokenB": 14843, + "approval to ": 14844, + "Deposi": 14845, + ";\\n }\\n _afterTokenTransfers(address(0), to, startTokenId, quantity": 14846, + "} else {\\n ": 14847, + "_ADDRESS_LENGTH": 14848, + "tokenA,\\n address tokenB": 14849, + "inSwapAndLiquify": 14850, + "delete _tokenApprovals[tokenId": 14851, + "ways": 14852, + "solhint-disable-next-line max-line-length": 14853, + "Returns an Ethereum Signed Message": 14854, + "SafeERC20 for ": 14855, + "increase the ": 14856, + "However": 14857, + "safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes memory _data\\n ": 14858, + "efficient ": 14859, + "\"Address: insufficient balance for call": 14860, + "paused(), \\\"": 14861, + "] -= 1;\\n ": 14862, + "(\\n address sender,\\n address recipient,\\n uint256 amount\\n ": 14863, + "niper": 14864, + "index out of bounds": 14865, + ",uint256 nonce,uint256 deadline": 14866, + "PAUSER_ROLE": 14867, + "authorizations": 14868, + "ProcessedIndex": 14869, + "global_collateral_": 14870, + "to.isContract()": 14871, + "History": 14872, + "c >= a": 14873, + ");\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\"": 14874, + "token/ERC20/ERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.": 14875, + "();\\n\\n // ": 14876, + ")`.": 14877, + "Erc": 14878, + "_RAT": 14879, + "`,\\n * ": 14880, + "value >= ": 14881, + ") public {\\n ": 14882, + ";\\n }\\n\\n /**\\n * @dev Call": 14883, + "bool is": 14884, + "bool whether ": 14885, + "tokensInto": 14886, + "to, uint value": 14887, + "deadAddress": 14888, + "Times": 14889, + "1820": 14890, + ".\\n * Use ": 14891, + " {\\n enum ": 14892, + "State ": 14893, + "proofElement": 14894, + ") internal view virtual returns (bool) {\\n ": 14895, + "OOL": 14896, + "(value) + ": 14897, + "claim ": 14898, + "@@@@@@@@@@@@@@@@@@@@@@@@": 14899, + "amount1In": 14900, + "amount0In": 14901, + "_PRECISION": 14902, + " not being zero, ": 14903, + "Bytes32Set storage set, bytes32 value": 14904, + "corresponding to the ": 14905, + "set._inner, value": 14906, + "computed ": 14907, + ", uint amountB": 14908, + "\"Address: low-level call with value failed": 14909, + "\"Address: low-level call failed\"": 14910, + "].add(amount);\\n emit Transfer": 14911, + "Gas optimization": 14912, + "These functions ": 14913, + "contract that wants to ": 14914, + "uint amountA, uint amountB": 14915, + "();\\n\\n _beforeTokenTransfers(address(0), to, startTokenId, quantity);\\n\\n // Overflows are ": 14916, + "https://github.com/OpenZeppelin/openzeppelin-contracts/pull/": 14917, + "benefit is lo": 14918, + "ERC721 token receiver interface": 14919, + "TokenGatedDrop": 14920, + " {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom": 14921, + "compati": 14922, + "% or less\"": 14923, + "Cycle": 14924, + "per block allowed.\"": 14925, + "tokenId.toString())": 14926, + "(account, address(0), amount);\\n\\n _afterTokenTransfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(\\n address owner,\\n address spender,\\n uint256 amount\\n ) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev ": 14927, + ": this is cheaper than ": 14928, + "_QUANT": 14929, + "} that receives the `v`,\\n * `": 14930, + "startTokenId = _currentIndex;\\n if (": 14931, + "(address owner,address spender": 14932, + " is also test": 14933, + "\"Address: insufficient balance for call\"": 14934, + " not being zero, but ": 14935, + "\"Address: low-level call with value failed\"": 14936, + "Gas optimization: this is cheaper than ": 14937, + "contract that wants to support ": 14938, + "benefit is lost if ": 14939, + "} that receives the `v`,\\n * `r` and `s` signature fields separately": 14940, + "(30": 14941, + ")`.\\n */\\n function _": 14942, + "b'": 14943, + "vest": 14944, + "vs` ": 14945, + "{\\n // ": 14946, + "recomm": 14947, + "relying ": 14948, + "ale ": 14949, + "toTypedData": 14950, + ", bytes memory data": 14951, + "unsafe": 14952, + "TokenReceiver": 14953, + "spender,\\n uint256 value": 14954, + "for contracts ": 14955, + "record ": 14956, + "proxi": 14957, + "burned (": 14958, + "(\\n address tokenA,\\n address tokenB": 14959, + "Propos": 14960, + "ATA ": 14961, + "s to a ": 14962, + "}.\\r\\n *\\r\\n * ": 14963, + "ren to implement ": 14964, + "staticcall": 14965, + "string,string": 14966, + "mary ": 14967, + "` is zero, ``from``'s ": 14968, + "Returns a token ID ": 14969, + "357": 14970, + "Before ": 14971, + "allows child": 14972, + "size > 0": 14973, + "Interface for any ": 14974, + "RecoverError.NoError": 14975, + "along with {": 14976, + "approved for all": 14977, + "(string calldata ": 14978, + "breaks ": 14979, + "access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _transferOwnership(_msgSender());\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev ": 14980, + "s\\n * from ": 14981, + "`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function ": 14982, + "token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom": 14983, + "at a given `index` ": 14984, + "0.9.0": 14985, + "short-signature fields separately": 14986, + "Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to": 14987, + "#eth_sign[`eth_sign": 14988, + ".\\n * Use along with {": 14989, + "Gas optimization: this is cheaper than requiring ": 14990, + "vs` short-signature fields separately": 14991, + "toTypedDataHash": 14992, + "allows children to implement ": 14993, + "Interface for any contract that wants to support ": 14994, + "\"M": 14995, + "(pair": 14996, + "Gnos": 14997, + "Kind": 14998, + "Upper": 14999, + "_functionCallWithValue": 15000, + "grow": 15001, + "rpc": 15002, + "function\\n * ": 15003, + "isPoints": 15004, + "ed in the ": 15005, + ");\\n _owner = ": 15006, + "(address tokenA, address tokenB": 15007, + "newWeight": 15008, + "adding": 15009, + "able only ": 15010, + "token was ": 15011, + "ethReceived": 15012, + "payee": 15013, + "ids, ": 15014, + "utils/Counters": 15015, + "\\n\\tfunction ": 15016, + "roles": 15017, + ") private _": 15018, + ";\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ": 15019, + "must be less than ": 15020, + " {\\n // ": 15021, + "uint amountETH": 15022, + "_treasury": 15023, + "er than the ": 15024, + "Most": 15025, + "pool.": 15026, + "\\n \\\"": 15027, + "39f": 15028, + "UintToAddress": 15029, + "Permit(address owner,address spender": 15030, + "Supply = ": 15031, + "the caller must be ": 15032, + ",\\n bytes32 root": 15033, + ")\\n external\\n returns (": 15034, + "highly ": 15035, + "ASCII ": 15036, + "basis point": 15037, + "target address that will receive the ": 15038, + "[from][": 15039, + "do not ": 15040, + "IERC1155": 15041, + "utils/introspection/ERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./": 15042, + "taken ": 15043, + "_operatorApprovals[": 15044, + ");\\n }\\n ": 15045, + "_feeDenominator": 15046, + "copy the ": 15047, + "average of ": 15048, + "\\n mapping(uint256 => uint256) private ": 15049, + ".\\r\\n *\\r\\n * Requirements:\\r\\n *\\r\\n * - ": 15050, + ".\\n //\\n // ": 15051, + ",string version": 15052, + "(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes memory _data\\n ) private returns (bool) {\\n ": 15053, + "EVENT_SIGNATURE": 15054, + "Agent": 15055, + "EIP712Domain(string name,string version": 15056, + "liquidityPairBalance": 15057, + "slot to ": 15058, + "target address that will receive the tokens": 15059, + "\"Swap amount cannot be ": 15060, + ";\\n ": 15061, + "AY": 15062, + "As of ": 15063, + "Lower": 15064, + "}\\n // ": 15065, + " // ": 15066, + "\\n }\\n ": 15067, + "inal": 15068, + ", if ": 15069, + "ancel": 15070, + "\\r\\n * - ": 15071, + "iph": 15072, + ".slot": 15073, + "accounts to ": 15074, + "ERC20Detailed": 15075, + ". By ": 15076, + "} while (": 15077, + "\\r\\n* ": 15078, + "by `operator": 15079, + ") external payable ": 15080, + ") external returns(": 15081, + "ffc": 15082, + "operator is ": 15083, + "] == ": 15084, + "ardinal": 15085, + "bytes32 s": 15086, + "openzeppelin/": 15087, + "utilities ": 15088, + ".\\n */\\n function _total": 15089, + "path[": 15090, + "in the Solidity ": 15091, + "LED": 15092, + ")\\n }\\n return ": 15093, + "int256 b": 15094, + ") {\\n // ": 15095, + "setApprovalForAll}.\\n */\\n function ": 15096, + "delegates ": 15097, + "minted (`": 15098, + ") {\\r\\n require(": 15099, + "decreased": 15100, + "stake ": 15101, + "\\n _revert(": 15102, + "() internal view virtual returns (uint256) {\\n return ": 15103, + "relay": 15104, + "optional data to send along with the call": 15105, + "Addition ": 15106, + "arithmetic operation": 15107, + ".code.length > 0": 15108, + "missing in the Solidity ": 15109, + "(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level ": 15110, + "particular ": 15111, + "{\\n return super._": 15112, + "math utilities ": 15113, + "Internal function to invoke {IERC721Receiver-onERC721Received} on a target ": 15114, + "_balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer": 15115, + ",\\r\\n address to,\\r\\n uint deadline": 15116, + " to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount": 15117, + "approval to current owner": 15118, + "bool whether the call correctly returned the expected magic value": 15119, + "minted (`_mint": 15120, + "missing in the Solidity language": 15121, + "math utilities missing in the Solidity language": 15122, + "\"src/": 15123, + "('": 15124, + ".\\\"": 15125, + ".wiki/": 15126, + "/API": 15127, + ">`\\n * - `": 15128, + "DEC": 15129, + "WE": 15130, + "`\\n */\\n function ": 15131, + "batch ": 15132, + "d4": 15133, + "dic": 15134, + "farm": 15135, + "ry ": 15136, + "{ ": 15137, + "acti": 15138, + "the fee ": 15139, + "ently": 15140, + "\\n\\n /// @dev ": 15141, + "torage": 15142, + "account.code.length > 0": 15143, + "an account's ": 15144, + "Coin": 15145, + ", uint256 p3) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(": 15146, + "with minimal ": 15147, + " is already ": 15148, + ", address p3) internal view {\\n\\t\\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature(\\\"log(": 15149, + "10 ": 15150, + " because the ": 15151, + "\\n *\\n * @dev ": 15152, + "arketing ": 15153, + "Time(": 15154, + "balance = ": 15155, + "transfer will be ": 15156, + "██╔": 15157, + "users": 15158, + "stored": 15159, + "Constant": 15160, + ", string memory p3) internal view {\\n\\t\\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature(\\\"log(": 15161, + ")\\\", p0, p1, p2));\\n\\t\\tignored;\\n\\t}\\n\\n\\tfunction ": 15162, + ".\\n mstore(": 15163, + ", bool p3) internal view {\\n\\t\\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature(\\\"log(": 15164, + "\\r\\n /**\\r\\n * ": 15165, + ", uint p3) internal view {\\n\\t\\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature(\\\"log(": 15166, + "mechanism for ": 15167, + "Address = _": 15168, + "hasRole(bytes32 role, address account": 15169, + "- 1].": 15170, + ".\\n\\n ": 15171, + "_ownerships": 15172, + "removeLiquidityWithPermit": 15173, + "for a given ": 15174, + "PaymentAddress": 15175, + "merkleProof": 15176, + "ed. It ": 15177, + "_tokenApprovals[tokenId] = to": 15178, + "Hook that is called before any token transfer. This includes ": 15179, + ")\\\", p0, p1, p2, p3));\\n\\t\\tignored;\\n\\t}\\n\\n\\tfunction log(address ": 15180, + ");\\n\\n /**\\n * @notice Returns the ": 15181, + "onlyAllowedOperator(from": 15182, + "swapExactETHForTokens": 15183, + "// solhint-disable-next-line func-name-mixedcase": 15184, + "address[] memory path": 15185, + "on-rpc": 15186, + ")\\\", p0, p1, p2, p3));\\n\\t\\tignored;\\n\\t}\\n\\n\\tfunction log(bool ": 15187, + ")\\\", p0, p1, p2, p3));\\n\\t\\tignored;\\n\\t}\\n\\n\\tfunction log(string memory ": 15188, + "uint256 c = a * b": 15189, + "hashedName": 15190, + "getRoleAdmin(bytes32 role": 15191, + "ELD": 15192, + "json-rpc": 15193, + "Enabled = true": 15194, + "\\u0026\\u0026": 15195, + "unique ": 15196, + "Overload of {ECDSA-tryRecover": 15197, + "Correction": 15198, + "approve to caller": 15199, + "lippage ": 15200, + "STORAGE": 15201, + "\"// SPDX-License-Identifier: MIT\\n// ERC721A Contracts v4.2.": 15202, + "projects[_projectId": 15203, + "https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522": 15204, + ".wiki/json-rpc": 15205, + ".wiki/json-rpc/API": 15206, + "(quantity": 15207, + "(receiver, ": 15208, + ",\\n // ": 15209, + "1e": 15210, + "490": 15211, + "Bonus": 15212, + "OTH": 15213, + "PR": 15214, + "]\\n *\\n * _Available since v4.": 15215, + "_target": 15216, + "db": 15217, + "\\npragma solidity ^0.8.": 15218, + "e a ": 15219, + "once": 15220, + "\\n @param ": 15221, + "deb": 15222, + "address[] ": 15223, + "tokenHolders": 15224, + "exit ": 15225, + "ed == false": 15226, + "transfer.\\n * ": 15227, + "ERC20Pausable": 15228, + "impl": 15229, + "from == ": 15230, + "The number of ": 15231, + ");\\n }\\n\\n /**\\n * @dev Convert": 15232, + "tokens list": 15233, + "prefix": 15234, + ";\\n uint8 ": 15235, + "buyOperationsFee": 15236, + "latform": 15237, + ");\\n uint256 ": 15238, + "amountsOut": 15239, + "initialSupply": 15240, + "royalties ": 15241, + "-= 1": 15242, + "sqrtPrice": 15243, + "SeaDrop(": 15244, + "vote ": 15245, + "purpose is ": 15246, + "reaks ": 15247, + "(uint256(uint160": 15248, + "pop(": 15249, + "paused = false": 15250, + "` is zero, `tokenId` will be burned by `from`.\\n * - `from` and `to` are never both zero.\\n */\\n function _": 15251, + "call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall": 15252, + "call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}": 15253, + "for {permit": 15254, + "\\n //////////////////////////////////////////////////////////////*/\\n\\n function ": 15255, + "times.\\n unchecked {\\n ": 15256, + "necessarily ": 15257, + "token/ERC721/IERC721.sol\"": 15258, + "FixedPoint.": 15259, + "complexity": 15260, + ".\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `quantity` must be greater than 0": 15261, + "`tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, `tokenId` will be burned by `from`.\\n * - `from` and `to` are never both zero.\\n */\\n function _": 15262, + "elopers ": 15263, + ") {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall": 15264, + "Capped": 15265, + "data bytes optional data to send along with the call": 15266, + ",uint256 value,uint256 nonce,uint256 deadline": 15267, + "overhead for tokenomic": 15268, + "Updates `owner` s allowance for `spender` based on spent `amount`.\\n *\\n * Does not update the allowance amount in case of infinite allowance.\\n * Revert if not enough allowance is available.\\n *\\n * Might emit an {Approval} event.\\n */\\n function _spendAllowance": 15269, + "token gated ": 15270, + "Gnosis ": 15271, + "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline": 15272, + "with minimal overhead for tokenomic": 15273, + "();\\n }\\n\\n /**\\n * @dev ": 15274, + "Bank": 15275, + "FD": 15276, + "Path": 15277, + "Right": 15278, + "_|": 15279, + "_newOwner": 15280, + "fit": 15281, + "hi": 15282, + "opp": 15283, + "nti": 15284, + "ing call": 15285, + "of tokens ": 15286, + "\\n *\\n * ": 15287, + "account to ": 15288, + ". If the ": 15289, + "ation of `": 15290, + "totalETHFee": 15291, + "Tokens(": 15292, + "signing ": 15293, + "balanceOf(": 15294, + "_AL": 15295, + " base ": 15296, + "buyBurnFee": 15297, + "(_token": 15298, + "\\n * @dev Interface for any contract that wants to support ": 15299, + "locked ": 15300, + "(address owner, uint256 index": 15301, + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ": 15302, + ".\\n mstore(0x": 15303, + "tryAdd": 15304, + "tryMul": 15305, + "`. This\\n * ": 15306, + "decrease ": 15307, + "interact ": 15308, + ")\\\", p0, p1, p2, p3));\\n\\t}\\n\\n\\tfunction log(uint256 ": 15309, + "501": 15310, + "Collateral ": 15311, + "swapExactTokensForETH": 15312, + "contracts.\\n */\\ninterface ": 15313, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./": 15314, + "wallets": 15315, + "BPT_": 15316, + "ticket": 15317, + "add to the ": 15318, + ", vs": 15319, + "(data);\\n return _verifyCallResult(success, returndata, errorMessage": 15320, + "Seconds": 15321, + "token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ": 15322, + "` from `from": 15323, + ")\\\", p0, p1, p2, p3));\\n\\t\\tignored;\\n\\t}\\n\\n\\tfunction log(uint ": 15324, + "Store the ": 15325, + ";\\n }\\n\\n function set": 15326, + "safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to": 15327, + "_AUX_COMPLEMENT": 15328, + "losed": 15329, + "protect against flash loan ": 15330, + "\"Must keep fees at ": 15331, + "191.\\n *\\n * See {recover}.\\n */\\n function ": 15332, + "ScalingFactor": 15333, + "-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall": 15334, + "composability": 15335, + "HASHED_NAME": 15336, + "\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}": 15337, + "move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to": 15338, + "https://eth.wiki/json-rpc/API": 15339, + "`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes calldata data\\n ": 15340, + "token was burned": 15341, + "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract": 15342, + "Gnosis Safe": 15343, + "token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId": 15344, + "protect against flash loan attack": 15345, + "', ": 15346, + "6e": 15347, + ";;": 15348, + "YDF": 15349, + "_/": 15350, + "_sender": 15351, + "paid ": 15352, + "sim": 15353, + "v3": 15354, + "three ": 15355, + ", can be ": 15356, + "\\n * constructor": 15357, + "ed from ": 15358, + ": transfer ": 15359, + "calldatasize": 15360, + "from a contract": 15361, + "operatorFilter": 15362, + "}\\n\\n ": 15363, + ".sol\\\";\\n\\nimport \\\"./": 15364, + "safeApprove": 15365, + "REC": 15366, + "(\\n address from,\\n address to,\\n uint256 amount\\n ) external returns (bool": 15367, + "Ether": 15368, + ")\\n {\\n require(": 15369, + "defaults to ": 15370, + "_balances[account] += amount": 15371, + "ordering ": 15372, + "ERC721 asset ": 15373, + "entire": 15374, + "contracts is ": 15375, + "\\\"\\n );\\n _": 15376, + "_TYPE_HASH": 15377, + "access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/": 15378, + "removeLiquidityETHSupportingFeeOnTransferTokens": 15379, + "[from] ": 15380, + "easily ": 15381, + "9a7": 15382, + "ayerZero": 15383, + "OF ": 15384, + "deposit ": 15385, + "bptAmountIn": 15386, + "tokenOfOwnerByIndex(address owner, uint256 index": 15387, + "\\r\\n */\\r\\n function ": 15388, + "revert TransferToNonERC721ReceiverImplementer();\\n ": 15389, + "keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n": 15390, + ");\\n\\n // Clear approvals from the previous owner\\n ": 15391, + "INSUFFICIENT": 15392, + "s.\\n uint64 ": 15393, + "Returns `true": 15394, + "Assumes ": 15395, + "with minimal overhead for tokenomics.\\n uint64 ": 15396, + "\\n * @dev Interface for any contract that wants to support safeTransfer": 15397, + " \\u003e ": 15398, + "/address": 15399, + "40, ": 15400, + "Boost": 15401, + "X128": 15402, + "ie": 15403, + "ys": 15404, + "ali": 15405, + ", Ownable ": 15406, + "devic": 15407, + "TokenSupply": 15408, + "index] = ": 15409, + "newValue": 15410, + "contract is not ": 15411, + "Exist": 15412, + "ffix": 15413, + "swapETHFor": 15414, + "Role = ": 15415, + "ed by calling ": 15416, + "ERC165, IERC165": 15417, + "` to protect against flash loan attack": 15418, + "can be circumvent": 15419, + "Char": 15420, + "interface is not ": 15421, + ")\\n }\\n }\\n}\\n\"": 15422, + ".sol\\\";\\nimport \\\"@openzeppelin/contracts-0.6/": 15423, + ", and does not provide ": 15424, + ".\\n // See: ": 15425, + "lastLpBurnTime": 15426, + "e.\\n ": 15427, + "_setImplementation": 15428, + "It must ": 15429, + "into the ": 15430, + "Token ID": 15431, + "if (!_": 15432, + "transferred to this contract ": 15433, + "like Gnosis Safe": 15434, + "wallets\\n * ": 15435, + ") == root": 15436, + "3._\\n */\\n function tryRecover": 15437, + ", breaks ": 15438, + "assumed to be ": 15439, + "You shouldn't ": 15440, + "whitelisted": 15441, + "DOMAIN_SEPARATOR() external view returns (bytes32": 15442, + "discouraged. It ": 15443, + ".code.length, which returns 0": 15444, + "s from contracts is ": 15445, + "Scri": 15446, + "`isContract` to protect against flash loan attack": 15447, + "a function callable only ": 15448, + "in construction, since the code is only stored at the end": 15449, + "currentAllowance = allowance(owner, spender);\\n require(": 15450, + "percentage of the ": 15451, + "Preventing call": 15452, + "tokenByIndex(uint256 index": 15453, + "reentrant call": 15454, + "c / a == b": 15455, + "callable if the ": 15456, + "since it can be circumvent": 15457, + "produces hash corresponding to the ": 15458, + "support for smart ": 15459, + "Multiplication ": 15460, + ") internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash": 15461, + ");\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover": 15462, + "_TRANSFER_EVENT_SIGNATURE": 15463, + "token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\"": 15464, + "security since it can be circumvent": 15465, + "Max wallet exceeded\"": 15466, + "rely on `isContract` to protect against flash loan attack": 15467, + "SafeERC20 for IERC20": 15468, + "ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfer": 15469, + "_QUANTITY": 15470, + "relying on ": 15471, + "for contracts in construction, since the code is only stored at the end": 15472, + "breaks composability": 15473, + "s\\n * from ERC721 asset ": 15474, + "highly discouraged. It ": 15475, + "(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call": 15476, + "// solhint-disable-next-line func-name-mixedcase\\n function ": 15477, + "]\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover": 15478, + "tokenHoldersMap": 15479, + "https://eth.wiki/json-rpc/API#eth_sign[`eth_sign": 15480, + "/address.code.length, which returns 0": 15481, + "ed by calling from a contract": 15482, + ", and does not provide security since it can be circumvent": 15483, + "like Gnosis Safe, and does not provide security since it can be circumvent": 15484, + ", breaks support for smart ": 15485, + "You shouldn't rely on `isContract` to protect against flash loan attack": 15486, + "s from contracts is highly discouraged. It ": 15487, + "a function callable only when the ": 15488, + "Preventing calls from contracts is highly discouraged. It ": 15489, + "ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset ": 15490, + "breaks composability, breaks support for smart ": 15491, + "like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract": 15492, + "You shouldn't rely on `isContract` to protect against flash loan attacks!": 15493, + "Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart ": 15494, + "-byte ": 15495, + "9f": 15496, + "Epoch": 15497, + "Rock": 15498, + "_n": 15499, + "kind ": 15500, + "lem": 15501, + "ral": 15502, + "====\\n *\\n * ": 15503, + "devFee": 15504, + "accr": 15505, + ".\\n *\\n * It must ": 15506, + "return its ": 15507, + "if they are ": 15508, + "} `tokenId` token is ": 15509, + " to confirm": 15510, + "recipient, the ": 15511, + "maxSellAmount": 15512, + "token holder": 15513, + "currentDelegate": 15514, + "idx": 15515, + "IND": 15516, + "IERC721} `tokenId` token is ": 15517, + "\\n // for contracts in construction, since the code is only stored at the end": 15518, + "`, this function is ": 15519, + "If any other ": 15520, + ".\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize": 15521, + ");\\n }\\n\\n function $": 15522, + "_tokenOwner": 15523, + "_tokenRoyaltyInfo": 15524, + "an {IERC721} `tokenId` token is ": 15525, + "ed in Solidity ": 15526, + ".\\n *\\n * The ": 15527, + "\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart ": 15528, + "`owner`.\\n */\\n function _": 15529, + ";\\r\\n }\\r\\n ": 15530, + "slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `": 15531, + "selector can be ": 15532, + "selector to confirm": 15533, + "Solidity selector to confirm": 15534, + "Implementation of ": 15535, + ";\\r\\n }\\r\\n ": 15536, + ";\\r\\n }\\r\\n\\r\\n ": 15537, + "Registe": 15538, + "percentage": 15539, + " in min": 15540, + "IERC721-safeTransferFrom}\\n * ": 15541, + "swapTokensForExactTokens": 15542, + "ByOwner": 15543, + "make a function callable only when the ": 15544, + "has been granted `role": 15545, + "value is returned ": 15546, + "\"@openzeppelin/contracts/utils/cryptography/": 15547, + "\\r\\n\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\n": 15548, + "ecrecover ": 15549, + " the token transfer.\\n * ": 15550, + "via {IERC721-safeTransferFrom}\\n * ": 15551, + "called.\\n *\\n * It must ": 15552, + "`account` has been granted `role": 15553, + "UniswapPair": 15554, + ".\\n *\\n * The selector can be ": 15555, + "\\n return account.code.length > 0": 15556, + "reverted.\\n *\\n * The selector can be ": 15557, + ",,,,,,,,,,,,,,,,": 15558, + "borrower": 15559, + "[IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!": 15560, + "hsiAddress": 15561, + "StorageSlot.get": 15562, + "bytes4(keccak256('": 15563, + ".onERC721Received.selector`.\\n */\\n function ": 15564, + "constructor execution.\\n\\n return account.code.length > 0": 15565, + "EaD": 15566, + "a good ": 15567, + "obtained in Solidity ": 15568, + " been granted `role`, emits a {RoleRevoked} event": 15569, + "_defaultRoyaltyInfo": 15570, + "or the interface is not ": 15571, + "Whenever an {IERC721} `tokenId` token is ": 15572, + "Modifier to make a function callable only when the ": 15573, + "implemented by the recipient, the ": 15574, + "\\n // of the constructor execution.\\n\\n return account.code.length > 0": 15575, + "transfer amount exceeds the maxTransactionAmount.\"": 15576, + "continue": 15577, + "_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved": 15578, + ";\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call": 15579, + "magnified": 15580, + "` if `account` has been granted `role": 15581, + "RecoveryMode": 15582, + "addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n uint256 currentAllowance = allowance(owner, spender);\\n require(": 15583, + "allowance(owner, spender) + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n uint256 currentAllowance = allowance(owner, spender);\\n require(": 15584, + "permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ": 15585, + "to provide a ": 15586, + "by `operator` from `from": 15587, + "transfer will be reverted.\\n *\\n * The selector can be ": 15588, + "contracts.\\n */\\ninterface IERC721Receiver": 15589, + "\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize": 15590, + "Returns `true` if `account` has been granted `role": 15591, + "transferred to this contract via {IERC721-safeTransferFrom}\\n * ": 15592, + "wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract": 15593, + "/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end": 15594, + "ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721Receiver": 15595, + "====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!": 15596, + "return its Solidity selector to confirm": 15597, + "`, this function is called.\\n *\\n * It must ": 15598, + "If any other value is returned ": 15599, + "\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract": 15600, + " the token transfer.\\n * If any other value is returned ": 15601, + "obtained in Solidity with `": 15602, + "or the interface is not implemented by the recipient, the ": 15603, + "Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * ": 15604, + ";\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}": 15605, + "by `operator` from `from`, this function is called.\\n *\\n * It must ": 15606, + "transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `": 15607, + "\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end": 15608, + "====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract": 15609, + "return its Solidity selector to confirm the token transfer.\\n * If any other value is returned ": 15610, + "or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `": 15611, + "Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must ": 15612, + "\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0": 15613, + "====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0": 15614, + "return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `": 15615, + "Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `": 15616, + ".\\r\\n ": 15617, + "0, \\\"": 15618, + "Yield": 15619, + "cb": 15620, + "dEaD": 15621, + "vault ": 15622, + "{\\n ": 15623, + "}: ": 15624, + "}.\\n */\\n ": 15625, + "returndatacopy": 15626, + ") is ": 15627, + "isBlacklisted": 15628, + "a transaction": 15629, + "Too": 15630, + "ass ": 15631, + "/**\\n@notice ": 15632, + "warn": 15633, + "bur": 15634, + "(address token": 15635, + "Indic": 15636, + "ERC721AS": 15637, + "at all": 15638, + "getOwner": 15639, + "did ": 15640, + "burnTokens": 15641, + "name() public view virtual override returns (string memory) {\\n return _name": 15642, + "symbol() public view virtual override returns (string memory) {\\n return _symbol": 15643, + "10, following the selected rounding direction": 15644, + " because ": 15645, + "buyTotalFee": 15646, + "taxFeeOnSell": 15647, + "baseTokenURI": 15648, + "uint amount1": 15649, + "To change ": 15650, + "admin, use {": 15651, + "Collect": 15652, + "admin role that ": 15653, + "] += amount;\\n ": 15654, + "New ": 15655, + "salt": 15656, + ";\\n uint256 public constant ": 15657, + "members": 15658, + "OperatorFilterRegistry ": 15659, + "/* ========": 15660, + "creator ": 15661, + "underlying": 15662, + "umentation ": 15663, + "(uint256 tokenId) public view virtual override returns (address) {\\n ": 15664, + "This function should only be called ": 15665, + "compiler's ": 15666, + "uint256[] memory) {\\n ": 15667, + "safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this ": 15668, + "isApprovedForAll(owner, _msgSender())": 15669, + "due to ": 15670, + "`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this ": 15671, + "ECDSA.recover": 15672, + "QuantityExceedsLimit": 15673, + "INonFungible": 15674, + "OTHER": 15675, + "swapETHForExactTokens": 15676, + "admin role that control": 15677, + "This function should only be called from the ": 15678, + "\"The ": 15679, + ")\\n // ": 15680, + "*/\\n ": 15681, + "FB": 15682, + "_address ": 15683, + "_length": 15684, + "_to, ": 15685, + "b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the ": 15686, + "done ": 15687, + "nest": 15688, + "tore the ": 15689, + "anal": 15690, + ", owner": 15691, + "256 bits": 15692, + "ing account had": 15693, + "minting\\n * ": 15694, + "approve}.\\n */\\n function ": 15695, + ", \\\"SafeERC20: ": 15696, + "permit ": 15697, + "bytes32 private constant _": 15698, + ".\\n */\\n function _safeMint(\\n address to": 15699, + "sellBurnFee": 15700, + ") internal virtual {\\r\\n require(": 15701, + "Payer": 15702, + ".\\n *\\n * Requirements:\\n *\\n * - the caller must be ": 15703, + "lastManual": 15704, + "outcom": 15705, + ".\\n let ": 15706, + "`owner`'s ": 15707, + "misplac": 15708, + ";\\r\\n }\\r\\n\\r\\n ": 15709, + "version of {": 15710, + "percentFor": 15711, + "712 ": 15712, + "e is misplac": 15713, + "(_msgSender(), operator, approved": 15714, + "their privileg": 15715, + "tokenURI}.\\n */\\n function ": 15716, + "Tokens array": 15717, + "4668": 15718, + "If the calling account had": 15719, + "........................": 15720, + "vote": 15721, + "via {grantRole} and {revokeRole": 15722, + "such as when a ": 15723, + "ed (such as when a ": 15724, + "return\\n interfaceId == type(": 15725, + "caller must own the token or be an approved operator.\\n */\\n error ": 15726, + "\\n ) internal pure returns (bool) {\\n return ": 15727, + "decla": 15728, + "s `role`. See {": 15729, + "interest ": 15730, + "optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721": 15731, + "getAmountsOut": 15732, + "`account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event": 15733, + "Fees[2": 15734, + "\\n // ": 15735, + ". This includes minting.\\n * And also called ": 15736, + "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens": 15737, + "often managed ": 15738, + "recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function ": 15739, + "Roles are often managed ": 15740, + "lose their privileg": 15741, + ".layout": 15742, + "observation": 15743, + "trusted devic": 15744, + "further ": 15745, + "utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to": 15746, + ") public virtual override returns (bool) {\\n address spender = _msgSender();\\n _spendAllowance(from, spender, amount);\\n _transfer(from, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, allowance(owner, spender) + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n uint256 currentAllowance = allowance(owner, spender);\\n require(": 15747, + "size := extcodesize(account": 15748, + "compromised (such as when a ": 15749, + "recommended to ": 15750, + "accounts to lose their privileg": 15751, + "mechanism for accounts to lose their privileg": 15752, + "purpose is to provide a ": 15753, + "(uint256(uint160(value))": 15754, + "if they are compromised (such as when a ": 15755, + "}: this function": 15756, + "admin role that controls `role`. See {": 15757, + "b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest ": 15758, + "via {grantRole} and {revokeRole}: this function": 15759, + "optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is ": 15760, + "Roles are often managed via {grantRole} and {revokeRole}: this function": 15761, + "trusted device is misplac": 15762, + "purpose is to provide a mechanism for accounts to lose their privileg": 15763, + "if they are compromised (such as when a trusted device is misplac": 15764, + "admin role that controls `role`. See {grantRole} ": 15765, + "\"_transfer:: Transfer Delay enabled. ": 15766, + ")\\r\\n ": 15767, + ".\\n\\n ": 15768, + "BAL": 15769, + "IRouter": 15770, + "_tokens": 15771, + "_register": 15772, + "`SafeMath": 15773, + "eB6": 15774, + "\\n ) private view returns (": 15775, + "t & 0x": 15776, + "address[](": 15777, + "imin": 15778, + "lef": 15779, + "iff": 15780, + ";\\n seriesSum += ": 15781, + "Address.sol)\\n\\npragma solidity ^0.8.": 15782, + "FromFees": 15783, + ") public onlyOwner {\\n ": 15784, + "0000dEaD": 15785, + "up to ": 15786, + "burn(uint256 amount": 15787, + "tokens will ": 15788, + "MintToZeroAddress": 15789, + "Option": 15790, + "`to` to ": 15791, + ",\\n uint256 denominator": 15792, + "ization ": 15793, + "LiquidityPair": 15794, + "``sender": 15795, + "NotInitialized": 15796, + ";\\n\\nimport \\\"@balancer-labs/v2-": 15797, + "storage slot": 15798, + "ExactETH": 15799, + "edition ": 15800, + "bool,uint,": 15801, + ", uint value": 15802, + "Register": 15803, + "e is the ": 15804, + "swapTokensForExactETH": 15805, + ")\\n } ": 15806, + "ERC2981: ": 15807, + "interfaceId == type(IERC721Metadata": 15808, + "calls to a ": 15809, + "p0, address p1, uint p2": 15810, + "p0, bool p1, uint p2": 15811, + "p0, string memory p1, uint p2": 15812, + "\\\\xe5": 15813, + "directly or ": 15814, + "_exists(tokenId), \\\"": 15815, + "p0, uint p1, address p2": 15816, + "p0, uint p1, string memory p2": 15817, + "p0, uint p1, bool p2": 15818, + "p0, uint p1, uint p2": 15819, + "ERC721Enumerable: ": 15820, + "\\\\xe3\\\\x82": 15821, + "extra data ": 15822, + "balanceOf}.\\n */\\n function balanceOf(address owner": 15823, + "OPERATOR_FILTER_REGISTRY.": 15824, + "(0, 0, ": 15825, + "set._values.length": 15826, + "Revokes `role` from the calling account.\\n *\\n * ": 15827, + "Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event": 15828, + "(\\n address token,\\n uint liquidity": 15829, + "_addTokenToOwnerEnumeration": 15830, + "isexemptfrommaxTX": 15831, + "\\x19": 15832, + "GSN ": 15833, + "verifies that a ": 15834, + "Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint": 15835, + "join ": 15836, + "sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(": 15837, + " ✓ ✓": 15838, + "setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved": 15839, + "math utilities missing in the Solidity language.\\n */\\nlibrary ": 15840, + ".layout().": 15841, + "Address.sol)\\n\\npragma solidity ^0.8.1": 15842, + "(\\n address token,\\n uint liquidity,\\n uint amountTokenMin,\\n uint amountETHMin,\\n address to,\\n uint deadline": 15843, + "\"H": 15844, + "'a'": 15845, + "'b'": 15846, + "2)": 15847, + "3b": 15848, + "VE": 15849, + "a7": 15850, + "bond": 15851, + "e1": 15852, + "saf": 15853, + "x,\\n uint256 ": 15854, + "ed).\\n *\\n * ": 15855, + "quote": 15856, + ".\\n *\\n * ": 15857, + ": reentrant call": 15858, + "or equal": 15859, + "an element": 15860, + "value;\\n }\\n\\n struct ": 15861, + "Transfer} event": 15862, + "Incenti": 15863, + ".sol\\u0027": 15864, + "setAutomatedMarketMakerPair": 15865, + "divide ": 15866, + "impro": 15867, + "sender` cannot be the zero address.\\n * - `": 15868, + "(uint256 _amount": 15869, + "symbol}.\\n */\\n function ": 15870, + "import \\u0027": 15871, + "override returns (bool) {\\n ": 15872, + "will revert ": 15873, + " b) + (": 15874, + "+ 1": 15875, + "Miner": 15876, + "Min,\\r\\n ": 15877, + "taxFeeOnBuy": 15878, + "&& to ": 15879, + "has not ": 15880, + "the owner or ": 15881, + "s are not ": 15882, + "es[i]": 15883, + "Initialize the ": 15884, + ") internal virtual {\\n if (": 15885, + "Adds the ": 15886, + "ADMIN": 15887, + "limited": 15888, + "}.\\n *\\n * To change ": 15889, + "OUT_": 15890, + "[0]": 15891, + "LP ": 15892, + "EndTime": 15893, + "abi.decode(": 15894, + "(sender, recipient, amount);\\n\\n uint256 ": 15895, + "revokeRole}.\\n *\\n * To change ": 15896, + "reentrancy-": 15897, + "-name}.\\n */\\n function ": 15898, + "Distribution": 15899, + "call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.delegatecall": 15900, + "(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to ": 15901, + "}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be ": 15902, + "wrapped": 15903, + "_setRoleAdmin}.\\n */\\n function ": 15904, + "{permit} method": 15905, + "es\\n * if they are compromised (such as when a trusted device is misplac": 15906, + "a role's admin, use {": 15907, + "one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign": 15908, + "`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function ": 15909, + "nextTokenId = tokenId + 1": 15910, + "and\\n * {revokeRole}.\\n *\\n * To change ": 15911, + "`sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom": 15912, + " {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account": 15913, + ") internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.delegatecall": 15914, + "benefit is lost if 'b'": 15915, + "Gas optimization: this is cheaper than requiring 'a'": 15916, + "bool whether the call correctly returned the expected magic value\\n */\\n function ": 15917, + "oppos": 15918, + "`. This\\n * produces hash corresponding to the ": 15919, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165 is IERC165 {\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165).interfaceId;\\n }\\n}\\n\"": 15920, + "Returns `true` if `account` has been granted `role`.\\n */\\n function ": 15921, + "purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplac": 15922, + "admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change ": 15923, + "Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function": 15924, + "sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: ": 15925, + "ed).\\n *\\n * If the calling account had": 15926, + "(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a ": 15927, + "one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function ": 15928, + "benefit is lost if 'b' is also test": 15929, + "Gas optimization: this is cheaper than requiring 'a' not being zero, but ": 15930, + "`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function ": 15931, + "purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had": 15932, + "`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash": 15933, + " can ": 15934, + "\"Max wallet exceeded\"": 15935, + "Past": 15936, + "TE": 15937, + "a\\n * ": 15938, + "mer": 15939, + "uint256 currentAllowance = ": 15940, + " = true": 15941, + "(address user": 15942, + "(address to, uint256 amount": 15943, + "Suffix": 15944, + "virtual returns (": 15945, + "ForExtraData": 15946, + "OwnershipNotInitialized": 15947, + "transferFrom}.\\n */\\n function ": 15948, + "(_to, ": 15949, + "sellTotalFee": 15950, + ".\\n */\\n constructor (": 15951, + ". This can be ": 15952, + "}.\\n */\\n function ownerOf": 15953, + "}.\\n */\\n function getApproved": 15954, + "useNonce": 15955, + ";\\r\\n }\\r\\n": 15956, + "\\n *\\n * Requirements:\\n *": 15957, + "tokensForOperations": 15958, + "count ": 15959, + ", uint liquidity": 15960, + " {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `": 15961, + "ownerOf}.\\n */\\n function ownerOf": 15962, + "xyz": 15963, + "operation is ": 15964, + "weight ": 15965, + "royalty.": 15966, + "getApproved}.\\n */\\n function getApproved": 15967, + ",\\n uint amountOutMin": 15968, + "(address target, bytes memory data, uint256 value": 15969, + "tokenId` token must be owned by `from`": 15970, + "know the ": 15971, + "ERC2309_QUANTITY": 15972, + "ERC2309QuantityExceedsLimit": 15973, + "parameters, ": 15974, + ");\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll": 15975, + ");\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved": 15976, + "venue": 15977, + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n require(b": 15978, + "01ffc": 15979, + "\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function ": 15980, + "zero.\\n */\\n function average": 15981, + "} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `": 15982, + "uniswap/": 15983, + "_EXTRA_DATA_COMPLEMENT": 15984, + "https://eips.ethereum.org/EIPS/eip-721[ERC721": 15985, + "purchase": 15986, + "uint amountIn,\\n uint amountOutMin": 15987, + "mload(add(signature, 0x20": 15988, + "];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved": 15989, + "1000000000": 15990, + " * _expTable": 15991, + ".\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`": 15992, + "redisFeeOnSell": 15993, + "recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer": 15994, + ";\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function ": 15995, + "(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall": 15996, + "mload(add(signature, 0x40": 15997, + ") / _ONE": 15998, + "\\n * @param tokenId uint256 ID of the token to be transferred": 15999, + "common/": 16000, + "cost of ": 16001, + "operate on `tokenId`": 16002, + "return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved": 16003, + ".\\r\\n */\\r\\n ": 16004, + "from address representing the previous owner of the given token ID\\n * @param to ": 16005, + "a, int256 b": 16006, + "Only one purchase ": 16007, + "-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.delegatecall": 16008, + "effectivel": 16009, + "s := mload(add(signature, 0x40": 16010, + "MAX_MINT_ERC2309_QUANTITY": 16011, + "state-changing ": 16012, + "ardinality": 16013, + "Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721": 16014, + "ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721Receiver {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `": 16015, + "ERC721AStorage": 16016, + "did not ": 16017, + "approve}.\\n */\\n function approve(address to, uint256 tokenId": 16018, + ") public virtual override returns (bool) {\\n address spender = _msgSender();\\n _spendAllowance(from, spender, amount);\\n _transfer(from, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, allowance(owner, spender) + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n uint256 currentAllowance = allowance(owner, spender);\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - subtractedValue);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves `amount` of tokens from ": 16019, + "`to` to operate on `tokenId`": 16020, + "_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role": 16021, + "Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account": 16022, + "OwnershipNotInitializedForExtraData": 16023, + "01ffc9a7": 16024, + "} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer": 16025, + "uint amountIn,\\n uint amountOutMin,\\n address[] calldata path,\\n address to,\\n uint deadline": 16026, + ".\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function ": 16027, + "from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens": 16028, + "a, int256 b) internal pure returns (int256": 16029, + "MAX_MINT_ERC2309_QUANTITY_LIMIT": 16030, + "Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] ": 16031, + "() {\\n require(": 16032, + "2;\\n result += ": 16033, + "Glob": 16034, + "cal": 16035, + "cess ": 16036, + "\\n/// ": 16037, + "s != ": 16038, + ", value": 16039, + "rocket": 16040, + "functions": 16041, + "endTime": 16042, + "uint256 nextTokenId = tokenId + 1": 16043, + "\\n * ": 16044, + "\\n function _": 16045, + "torage ": 16046, + "in order ": 16047, + "(address delegatee": 16048, + "\\r\\n ": 16049, + ";\\n\\n mapping (address => ": 16050, + "(\\n uint amountIn,\\n uint amountOutMin,\\n address[] calldata path,\\n address to,\\n uint deadline": 16051, + "@@@@@@": 16052, + "implementing ": 16053, + "`.\\r\\n *\\r\\n * ": 16054, + "returns (bool)": 16055, + "exists(": 16056, + "feeRate": 16057, + "\"@openzeppelin/contracts/token/ERC721/IERC721.sol\"": 16058, + "useL": 16059, + "MAN": 16060, + "E_D": 16061, + "previousExtraData": 16062, + "generation": 16063, + "accessor": 16064, + "string,address": 16065, + "string,bool": 16066, + "doesn't": 16067, + "cannot exceed ": 16068, + "== 0) revert ": 16069, + "Array ": 16070, + "prevOwnership.addr": 16071, + "(\\n uint256 x,\\n uint256 ": 16072, + "ReentrancyGuard: reentrant call": 16073, + "requested ": 16074, + "ptr, ": 16075, + ");\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`": 16076, + "Snapshots": 16077, + "Redemption": 16078, + "precision ": 16079, + "throw ": 16080, + "_roles[role].members[account": 16081, + "removed from ": 16082, + "takes the ": 16083, + "set._inner, bytes32(uint256(uint160(value))": 16084, + "ayout:": 16085, + "wrap": 16086, + " ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of ": 16087, + "recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ": 16088, + "_moveDelegates": 16089, + "Whether the ": 16090, + "Migration": 16091, + "IVault.": 16092, + "IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is ": 16093, + ");\\n\\n /**\\n * @dev Revert with an error ": 16094, + "low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {": 16095, + "Library for ": 16096, + "sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ": 16097, + "data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function ": 16098, + "recommended to use ": 16099, + "import \\u0027./": 16100, + "-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name": 16101, + "(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {": 16102, + "from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred": 16103, + "& b) + (": 16104, + "2e": 16105, + "74": 16106, + "Sol": 16107, + "Take": 16108, + "V1": 16109, + "_router": 16110, + "_dstChainId": 16111, + "duplic": 16112, + "frozen": 16113, + "perf": 16114, + "ry": 16115, + "ui": 16116, + "indirectly": 16117, + ", and": 16118, + "token0 ": 16119, + "is\\n ": 16120, + "a & b) + (": 16121, + ") external onlyOwner {\\n ": 16122, + "that can ": 16123, + "air ": 16124, + "The new ": 16125, + ";\\n\\n /**\\n * @notice ": 16126, + "only way to ": 16127, + "BuyBack": 16128, + "ERC721A, ": 16129, + ");\\r\\n\\r\\n ": 16130, + "rence ": 16131, + "get them": 16132, + "signature parameters, ": 16133, + "NOT_": 16134, + "ERC20 allowance ": 16135, + "When the ": 16136, + "Remote": 16137, + ") internal {\\n uint256 ": 16138, + ", which can be used to ": 16139, + "instead of the ": 16140, + "send a transaction": 16141, + "currSlot": 16142, + "OLD": 16143, + "and the only way to ": 16144, + "Prior": 16145, + "138": 16146, + "0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF": 16147, + "ownership.burned": 16148, + "clusive": 16149, + "token/ERC721/extensions/IERC721Enumerable": 16150, + "'s\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had": 16151, + "call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-call": 16152, + "92F": 16153, + "s\\n (bool success, bytes memory returndata) = target": 16154, + "_dollar": 16155, + "manualBurn": 16156, + "18 decimal ": 16157, + "Remaining": 16158, + ";\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function ": 16159, + "ds-test": 16160, + "switch ": 16161, + "alpha": 16162, + ";\\n }\\n if (t & 0x": 16163, + "toshis": 16164, + " in mind ": 16165, + "ecrecover takes the ": 16166, + "directly or indirectly": 16167, + "Adds the {permit} method": 16168, + " {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount": 16169, + "admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {": 16170, + "Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had": 16171, + ";\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol": 16172, + "-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol": 16173, + "signature parameters, and the only way to ": 16174, + ", which can be used to change ": 16175, + "call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target": 16176, + "Adds the {permit} method, which can be used to change ": 16177, + "signature parameters, and the only way to get them": 16178, + "\"/": 16179, + "9e": 16180, + "FLOW": 16181, + "_s": 16182, + ", from, ": 16183, + ");\\r\\n event ": 16184, + "ing into ": 16185, + "imag": 16186, + "elimin": 16187, + " = _ownership": 16188, + "es to ": 16189, + "s:\\n *\\n * ": 16190, + "value for the ": 16191, + "the zero address\\\");\\r\\n\\r\\n ": 16192, + "the\\r\\n * ": 16193, + "MintPer": 16194, + ").min ": 16195, + ",\\n uint256 amount": 16196, + "Allowance ": 16197, + "updates are ": 16198, + "(_IMPLEMENTATION_SLOT": 16199, + "sellOperationsFee": 16200, + ".\\n * @return ": 16201, + " == owner": 16202, + ") {\\n return ": 16203, + "_burn(account, amount": 16204, + "Root ": 16205, + "er is not guarante": 16206, + "approvals to be ": 16207, + "Slot(bytes32 slot) internal pure returns (": 16208, + " > 0) {\\n // ": 16209, + "tokenId The ": 16210, + "Length = ": 16211, + "initialBalance": 16212, + "`from` to `to`.\\n *\\n * This internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n */\\n function _transfer": 16213, + "Funds": 16214, + "access/IAccessControl": 16215, + "== 0) ": 16216, + "slot of ": 16217, + "UND": 16218, + "78 ": 16219, + "keccak256(\\n ": 16220, + "order is not guarante": 16221, + ", as defined ": 16222, + "sales ": 16223, + "Memory": 16224, + ". These ": 16225, + ".\\n * @param ": 16226, + "IERC777": 16227, + "helper ": 16228, + "Extension of ": 16229, + "execute": 16230, + "-2612": 16231, + "override(ERC165, IERC165": 16232, + "still allows ": 16233, + "][operator] = approved;\\n emit ApprovalForAll": 16234, + "];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function ": 16235, + "revealed": 16236, + ") external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom": 16237, + "_transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function ": 16238, + "redisFeeOnBuy": 16239, + "made via ": 16240, + ") {\\n // ": 16241, + "simply ": 16242, + "ed as updates are ": 16243, + ", \\\"!auth": 16244, + "character ": 16245, + "filtered operators and ": 16246, + "branch": 16247, + ".\\n * Note that order is not guarante": 16248, + "address or its subscription": 16249, + "D576": 16250, + "made.\\n */\\n function ": 16251, + ";\\n\\n/**\\n * @dev Interface of ": 16252, + "Registered": 16253, + ";\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall": 16254, + "percentForLPBurn": 16255, + "recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount": 16256, + ".\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer": 16257, + "Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, includ": 16258, + "-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function ": 16259, + "approvals to be made via ": 16260, + "ed as updates are made.\\n */\\n function ": 16261, + ".\\n * Note that order is not guaranteed as updates are made.\\n */\\n function ": 16262, + " p0) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(bytes": 16263, + "\"F": 16264, + "$/": 16265, + "FE_": 16266, + "Rig": 16267, + "[sender": 16268, + "];\\n\\n // ": 16269, + "met": 16270, + "vs\\n ": 16271, + "y,\\n uint256 denominator": 16272, + "~~": 16273, + "int ": 16274, + "returnData": 16275, + "the sum of all ": 16276, + "ally": 16277, + "exclude": 16278, + "as\\n * ": 16279, + "ing of the ": 16280, + "imd": 16281, + "Ids": 16282, + "accountHash": 16283, + "Trans": 16284, + "short ": 16285, + "Inst": 16286, + "index for the ": 16287, + ";\\n address ": 16288, + ";\\n }\\n }\\n\\n ": 16289, + ";\\n for (uint256 i = 0; i < ": 16290, + "onlyMinter": 16291, + ";\\n\\n /// @dev ": 16292, + "swapRouter": 16293, + "will fail": 16294, + "rare": 16295, + "RoleData": 16296, + "(_packedOwnershipOf(tokenId": 16297, + "TaxFee": 16298, + "string memory) {\\r\\n return ": 16299, + "ROM": 16300, + ", and thus ": 16301, + "Convex": 16302, + "reflection": 16303, + ";\\n }\\n\\n /**\\n * ": 16304, + "At(address registrant": 16305, + "summ": 16306, + "rewardToken": 16307, + "SAFE_": 16308, + "paused.\\n */\\n modifier ": 16309, + "addition overflow": 16310, + "\\\");\\n return c": 16311, + ")\\n )\\n ": 16312, + ";\\r\\n ": 16313, + "RewardsFee": 16314, + "(address(0), to, tokenId);\\n\\n ": 16315, + "checkpoints[": 16316, + "Curve ": 16317, + "F5D576": 16318, + "aunch": 16319, + "SnapshotId": 16320, + "ILL": 16321, + "proxy.": 16322, + "meaning ": 16323, + "FE92F": 16324, + "Staked": 16325, + "1)`.": 16326, + ",\\n bytes32 r,\\n bytes32 vs\\n ": 16327, + "ceilDiv": 16328, + "r := mload(add(signature, 0x20": 16329, + "1B20": 16330, + "pause() internal virtual ": 16331, + "(\\n bytes32 hash,\\n bytes32 r,\\n bytes32 vs\\n ": 16332, + "DDFE92F": 16333, + "access to ": 16334, + "\\n ) external payable;\\n\\n /**\\n * @dev ": 16335, + "First": 16336, + "Purchase": 16337, + "A4501": 16338, + "hasRole(role, account)) {\\n _roles[role].members[account": 16339, + "E7357": 16340, + "on\\r\\n * overflow": 16341, + "Wrappers over Solidity's arithmetic operation": 16342, + "solhint-disable-next-line max-line-length\\n require(": 16343, + "Erc20": 16344, + "alias": 16345, + "46681B20": 16346, + "(\\n uint256 x,\\n uint256 y,\\n uint256 denominator": 16347, + "0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576": 16348, + "At(address registrant, uint256 index": 16349, + "DDFE92F46681B20": 16350, + "A4501DDFE92F46681B20": 16351, + "E7357A4501DDFE92F46681B20": 16352, + "0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20": 16353, + "\"\\x19": 16354, + "%@": 16355, + "() internal view virtual override returns (": 16356, + "* _": 16357, + "9d": 16358, + "IWETH": 16359, + "Sent": 16360, + "TY": 16361, + "_addedValue": 16362, + "ced": 16363, + "growth": 16364, + "s\\n // ": 16365, + "vested": 16366, + "will": 16367, + "enough": 16368, + "onSwap": 16369, + "\\n );\\n\\n ": 16370, + "unn": 16371, + "ac58": 16372, + "is to use ": 16373, + "to mint": 16374, + "from] ": 16375, + "accord": 16376, + "ular": 16377, + "in this ": 16378, + "at `index": 16379, + "key ": 16380, + "swapFeePercentage": 16381, + " ": 16382, + "@@@@@": 16383, + "(_projectId": 16384, + "s, and ": 16385, + "Minim": 16386, + "`tokenId` will be ": 16387, + ")\\n private": 16388, + "248": 16389, + "ARY": 16390, + ";\\n }\\n\\n function get": 16391, + "version of the ": 16392, + "s = new uint256": 16393, + "_buyLiquidityFee": 16394, + "instead of ": 16395, + "ATION_TYPEHASH": 16396, + "solhint-disable ": 16397, + "give ": 16398, + "Bytes32Set storage set": 16399, + "keeper": 16400, + "Governance ": 16401, + "\\n override\\n ": 16402, + "80ac58": 16403, + " = 1 << ": 16404, + "batchSize": 16405, + "except the ": 16406, + "safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) public virtual override {\\n ": 16407, + ".\\r\\n */\\r\\n function ": 16408, + "when dividing by zero.\\n *\\n * Counterpart to Solidity's `": 16409, + "_removeTokenFromAllTokensEnumeration": 16410, + "currently is to use ": 16411, + "E_PERCENT": 16412, + "_addTokenToAllTokensEnumeration": 16413, + "EnumerableSet.AddressSet": 16414, + "(\\n bytes32 hash,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ": 16415, + "\\\"],\\n [\\\"H": 16416, + "allowing approvals to be made via ": 16417, + "StorageSlot.getAddressSlot": 16418, + "}.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function ": 16419, + "``sender``'s ": 16420, + "ecrecover takes the signature parameters, and the only way to get them": 16421, + ", as defined in\\n * ": 16422, + "currently is to use assembly": 16423, + "allowing approvals to be made via signatures": 16424, + " ether": 16425, + "\"S": 16426, + "\"SafeERC20: ": 16427, + "(c": 16428, + "(see": 16429, + "+= _": 16430, + "qty": 16431, + "vShare": 16432, + "\\n/// @notice ": 16433, + "\\n\\n uint256 ": 16434, + "\\n struct ": 16435, + "unnecessary": 16436, + "is, ": 16437, + "icate": 16438, + "usage ": 16439, + "20 bytes ": 16440, + ".\\n *\\n * WARNING: ": 16441, + "primary ": 16442, + "value (": 16443, + "its L": 16444, + ").sub(": 16445, + "oldWeight": 16446, + " batch ": 16447, + "started": 16448, + "center": 16449, + "IERC20-allowance": 16450, + "preser": 16451, + "append": 16452, + "Pointer": 16453, + " `": 16454, + "gas to ": 16455, + ") {\\n require(value >= ": 16456, + "&& value <= type(": 16457, + ")\\n external": 16458, + "ing a message ": 16459, + ", the swap ": 16460, + "\\n * @title": 16461, + ")\\n external\\n view": 16462, + "[EIP-2612": 16463, + "funds": 16464, + "ates an ": 16465, + "mapping (address =\\u003e ": 16466, + "state.\\n *\\n * Requirements:\\n *\\n * - The contract ": 16467, + "auxili": 16468, + "(uint256 value) internal pure returns (uint": 16469, + "arithm": 16470, + "SignedMintValidation": 16471, + "decrement the ": 16472, + ":\\n *\\n * - `": 16473, + "starting token ID": 16474, + "freeMemory": 16475, + "timelockList": 16476, + "following is ": 16477, + "ed\\n * to ": 16478, + "ing\\n * the ": 16479, + "reserve ": 16480, + "];\\n\\n if (": 16481, + "Permit extension ": 16482, + "marked ": 16483, + "insert": 16484, + "token/ERC721/IERC721Receiver.sol\"": 16485, + "Upgraded": 16486, + "hashTypedDataV4(": 16487, + "https://eips.ethereum.org/EIPS/eip-712#": 16488, + "https://eips.ethereum.org/EIPS/eip-2612[EIP-2612": 16489, + "`account`.\\n */\\n event ": 16490, + "4.0 (": 16491, + "receive() external payable {": 16492, + "RARELOOKS": 16493, + "Hook that is called before any token transfer. This includes minting\\n * ": 16494, + "/* ========== ": 16495, + " {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom": 16496, + ").min && value <= type(": 16497, + ") {\\n require(value >= type(": 16498, + "Permit extension allowing approvals to be made via signatures": 16499, + " D": 16500, + "(address, ": 16501, + "0)\\n ": 16502, + "Anti": 16503, + "Bits L": 16504, + "HI": 16505, + "TO": 16506, + "_g": 16507, + "_sellLiquidityFee": 16508, + "due": 16509, + "kind": 16510, + "rf": 16511, + "sch": 16512, + "repe": 16513, + "s save ": 16514, + "inner": 16515, + "unit ": 16516, + "uint256)\"": 16517, + "amond": 16518, + "is within bound": 16519, + "account is ": 16520, + "account. By ": 16521, + "not relying on ": 16522, + ";\\n\\n address public ": 16523, + "ethier": 16524, + "mapping(address =\\u003e ": 16525, + "Buffer": 16526, + "cannot be removed from ": 16527, + "have a ": 16528, + ";\\n // ": 16529, + "is not required to ": 16530, + ".sol\\\";\\nimport \\\"@balancer-labs/v2-": 16531, + "MetadataUri": 16532, + "account doesn't": 16533, + "presenting a message ": 16534, + "fees. ": 16535, + "note that ": 16536, + "generating ": 16537, + "Allowlist": 16538, + "();\\n uint256 ": 16539, + "();\\n }\\n ": 16540, + "which to ": 16541, + ") internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: ": 16542, + "renounceRole": 16543, + "_currentIndex ": 16544, + "[0..": 16545, + "Can be ": 16546, + "s with added ": 16547, + "subtraction overflow": 16548, + "Issu": 16549, + "implementation for ": 16550, + "need to send a transaction": 16551, + ").\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub": 16552, + ");\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner": 16553, + "Ether at all": 16554, + ".\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint": 16555, + ".\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value": 16556, + "uniswap ": 16557, + "Array(": 16558, + "type `": 16559, + "Delete the ": 16560, + "don't need to ": 16561, + "JoinExitInvariant": 16562, + "(address registrant, address registrant": 16563, + "(\\n address ": 16564, + "hold Ether at all": 16565, + "pair cannot be removed from ": 16566, + "revoked `role": 16567, + "_takeTeam": 16568, + "Crv": 16569, + "signed by the account. By ": 16570, + "(see {IERC20-allowance": 16571, + "< b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of ": 16572, + "\\n *\\n * Emits a {": 16573, + "Apach": 16574, + "Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `": 16575, + ";\\npragma experimental ABIEncoderV2": 16576, + "token holder account doesn't": 16577, + "an account's ERC20 allowance ": 16578, + ".onERC721Received.selector`.\\n */\\n function onERC721Received(\\n address operator,\\n address from,\\n uint256 tokenId,\\n bytes calldata data\\n ) external returns (bytes4": 16579, + "(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll": 16580, + "Initialize the next ": 16581, + "common/ERC2981": 16582, + "Adds the {permit} method, which can be used to change an account's ERC20 allowance ": 16583, + ", and thus is not required to ": 16584, + "Bits Layout:": 16585, + "presenting a message signed by the account. By ": 16586, + "need to send a transaction, and thus is not required to ": 16587, + "(see {IERC20-allowance}) ": 16588, + "Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) ": 16589, + "presenting a message signed by the account. By not relying on ": 16590, + "need to send a transaction, and thus is not required to hold Ether at all": 16591, + "(gas": 16592, + "AMM": 16593, + "FA": 16594, + "] `": 16595, + "`balance ": 16596, + "fraction": 16597, + "safely ": 16598, + "}\\n\\n ": 16599, + "\\npragma solidity ^0.8.0": 16600, + "unpacked ": 16601, + "ork": 16602, + "// ERC165 interface ID for ": 16603, + "\\n * ": 16604, + "ve/": 16605, + "be used by ": 16606, + " = address(uint160(": 16607, + "approx": 16608, + "32-byte ": 16609, + "} for ": 16610, + "zero and not ": 16611, + "ForPenalty": 16612, + "\\r\\n ) external returns (": 16613, + "swapRequest": 16614, + "zero).": 16615, + "blocking": 16616, + "] = prevOwnershipPacked": 16617, + "false;\\n }\\n }\\n\\n /**\\n * @dev ": 16618, + "overflow because the ": 16619, + "= _packedOwnershipOf(tokenId": 16620, + "Ensure the ": 16621, + "_mint(": 16622, + "Updates: ": 16623, + "nextInitializ": 16624, + "expired": 16625, + "block.timestamp >= ": 16626, + "; // Updates: ": 16627, + "given by the ": 16628, + ") / 100": 16629, + "packed value is ": 16630, + "Slot` with member `value` located at `slot`.\\n */\\n function get": 16631, + " bits\\n *\\n * ": 16632, + "delete is the ": 16633, + "` operator.\\r\\n *\\r\\n * Requirements:\\r\\n *\\r\\n * - ": 16634, + "renounce ": 16635, + "_balances[account] += amount;\\n ": 16636, + "lptoken": 16637, + "have been initializ": 16638, + "Storage ": 16639, + "ates a ": 16640, + "reentrant": 16641, + "i.function": 16642, + ".selector ^ ": 16643, + "();\\n\\n if (": 16644, + "TRANSFER_": 16645, + "auxCasted ": 16646, + "approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount": 16647, + "incrementing": 16648, + "\\t\\t// ": 16649, + "uint24(": 16650, + "i.e. packed value is ": 16651, + ": invalid signature": 16652, + "\\\");\\n _;\\n }\\n\\n ": 16653, + "snapshotId": 16654, + "callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, ": 16655, + "ed (i.e. `": 16656, + "absTick": 16657, + ";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId": 16658, + "trigg": 16659, + "validate": 16660, + "for `ownerOf(": 16661, + "ownership.addr != address(0)": 16662, + "If the next slot's ": 16663, + "address is zero and not ": 16664, + ".\\r\\n *\\r\\n * ": 16665, + "tokenId + 1)`.": 16666, + "prevOwnershipPacked = _packedOwnershipOf(tokenId": 16667, + "token/ERC721/extensions/IERC721Metadata.sol\"": 16668, + ").interfaceId ||\\n super.supportsInterface(interfaceId": 16669, + "may not have been initializ": 16670, + "(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.delegatecall": 16671, + "decimals = 18": 16672, + "getRoleMemberCount": 16673, + "_packedOwnerships[nextTokenId] = prevOwnershipPacked": 16674, + "If the next slot is within bound": 16675, + "If the next slot may not have been initializ": 16676, + "withdrawableDividend": 16677, + "'s' value": 16678, + "_status = _NOT_ENTERED": 16679, + "maintain correctness for `ownerOf(": 16680, + "utchAuction": 16681, + "burned (i.e. packed value is ": 16682, + "slot to maintain correctness for `ownerOf(": 16683, + "iphery": 16684, + "ed == false`) ": 16685, + ");\\n }\\n\\n /**\\n * @dev Converts an ": 16686, + "operation is unnecessary": 16687, + ") public virtual override returns (bool) {\\n address spender = _msgSender();\\n _spendAllowance(from, spender, amount);\\n _transfer(from, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, allowance(owner, spender) + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n uint256 currentAllowance = allowance(owner, spender);\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - subtractedValue);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves `amount` of tokens from `from` to `to`.\\n *\\n * This internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n */\\n function _transfer": 16688, + "slot of tokenId": 16689, + "recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer": 16690, + "-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (": 16691, + ", the swap operation is unnecessary": 16692, + "Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - ": 16693, + "Initialize the next slot to maintain correctness for `ownerOf(": 16694, + "unpacked `TokenOwnership` struct ": 16695, + "nextInitialized == false`) ": 16696, + "; // Updates: `balance ": 16697, + "ed (i.e. `nextInitialized == false`) ": 16698, + "If the next slot's address is zero and not ": 16699, + "If the next slot is within bounds.": 16700, + "If the next slot may not have been initialized (i.e. `nextInitialized == false`) ": 16701, + "burned (i.e. packed value is zero).": 16702, + "Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.": 16703, + "If the next slot's address is zero and not burned (i.e. packed value is zero).": 16704, + "\"Buy ": 16705, + "& (": 16706, + "')) == ": 16707, + "Paid": 16708, + "Wad": 16709, + "[_tokenId": 16710, + "`_to": 16711, + "e0": 16712, + "frequency": 16713, + "hard": 16714, + "ield ": 16715, + "s or ": 16716, + "s all ": 16717, + ", uint64 ": 16718, + "ed\\n // ": 16719, + "ately ": 16720, + "pped ": 16721, + "a block": 16722, + "controller": 16723, + "ety ": 16724, + "ect to ": 16725, + "elaps": 16726, + "\\n * need to send a transaction, and thus is not required to hold Ether at all": 16727, + "affi": 16728, + "most": 16729, + "*******": 16730, + "maxPer": 16731, + "checks.": 16732, + "can overflow": 16733, + "idth": 16734, + "See {IERC721-": 16735, + "` to the owner": 16736, + "_SWAP": 16737, + "of `tokenId": 16738, + "tokensForLiquidity ": 16739, + "\\r\\n *\\r\\n * ": 16740, + "digitalMedia": 16741, + "_rate": 16742, + "$$ ": 16743, + "CONSTRUCT": 16744, + "Config.": 16745, + "VERFLOW": 16746, + "].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) ": 16747, + "sent in ": 16748, + "expensive": 16749, + "isExcludedFromFee": 16750, + "bitmap": 16751, + "_approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20": 16752, + "int24 ": 16753, + "onlyRole(getRoleAdmin(role": 16754, + "BITPOS_NUMBER_MINTED) | ": 16755, + "by\\n * presenting a message signed by the account. By not relying on ": 16756, + "totalSupply() * ": 16757, + "string memory name, string memory ": 16758, + "_INTERFACE_ID_": 16759, + "numberMinted += quantity": 16760, + "} to enumerate all ": 16761, + "paused(), \\\"Pausable: ": 16762, + "` is zero, ``from``'s `tokenId` will be ": 16763, + "_dollar_value": 16764, + ", as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612": 16765, + "Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612": 16766, + ") internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer": 16767, + "token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all": 16768, + ".onERC721Received.selector`.\\n */\\n function onERC721Received(\\n address operator,\\n address from,\\n uint256 tokenId,\\n bytes calldata data\\n ) external returns (bytes4);\\n}\\n\"": 16769, + "affili": 16770, + "].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on ": 16771, + "BITPOS_NUMBER_MINTED) | 1": 16772, + "Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on ": 16773, + "\"Sell ": 16774, + "(_msgSenderERC721A": 16775, + "(operator, ": 16776, + "/^": 16777, + "3, ": 16778, + "Platform": 16779, + "_swapEnabled": 16780, + "_time": 16781, + "_dexRouter": 16782, + "_contains": 16783, + "_srcAddress": 16784, + "`proof": 16785, + "lector": 16786, + "market ": 16787, + "t.": 16788, + ") are ": 16789, + "the transaction ": 16790, + "is missing role ": 16791, + "// If the next slot is within bounds.": 16792, + "contain ": 16793, + "devFeeReceiver": 16794, + "Token\"": 16795, + ",\\n bool": 16796, + "prov": 16797, + " of the\\n // ": 16798, + ") external payable": 16799, + "Callback": 16800, + "up the ": 16801, + "its own ": 16802, + "Optim": 16803, + "0x[0-9a-f]{": 16804, + "Requirements:\\n * - ": 16805, + "mod(": 16806, + "of the revert reason is ": 16807, + "LiquidityWith": 16808, + "remove the ": 16809, + "ate a ": 16810, + ".\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length": 16811, + "in the set. O(1).\\n *\\n * ": 16812, + "token/common/ERC2981": 16813, + "\"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol\"": 16814, + "expon": 16815, + "assembly to avoid ": 16816, + "IMAL": 16817, + "the\\n * array, and it may change when more values are added or removed": 16818, + ") public virtual override onlyRole(getRoleAdmin(role": 16819, + "_setOwner(": 16820, + "put in ": 16821, + "account (0x[0-9a-f]{": 16822, + "\\n ) external payable ": 16823, + "keys": 16824, + "(0x[0-9a-f]{": 16825, + "next token ID": 16826, + "original": 16827, + "Price = ": 16828, + ":\\n *\\n * ": 16829, + "masking": 16830, + ", \\\"SafeMath: division by zero": 16831, + "regular expres": 16832, + "approveMax, uint8 v, bytes32 r, bytes32 s": 16833, + "following regular expres": 16834, + "upgrades ": 16835, + "(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n ": 16836, + "AccessControl: account (0x[0-9a-f]{": 16837, + "uint256) private _balances": 16838, + "}) is missing role ": 16839, + "utils/cryptography/ECDSA": 16840, + "proportional": 16841, + "format of the revert reason is ": 16842, + "Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed": 16843, + "signatory": 16844, + "value stored at position `index` in the set. O(1).\\n *\\n * ": 16845, + "becomes ": 16846, + "blockNumber ": 16847, + "writing ": 16848, + ".\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator": 16849, + "})$/": 16850, + "sqrtPriceX96": 16851, + "Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the ": 16852, + "\\\"],\\n [\\\"Hair ": 16853, + "given by the following regular expres": 16854, + "(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {": 16855, + "_packedOwnerships[nextTokenId] = prevOwnershipPacked;": 16856, + "frequencyIn": 16857, + "(_msgSenderERC721A(), ": 16858, + "/^AccessControl: account (0x[0-9a-f]{": 16859, + ") public virtual override onlyRole(getRoleAdmin(role)": 16860, + "}) is missing role (0x[0-9a-f]{": 16861, + "format of the revert reason is given by the following regular expres": 16862, + "Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length": 16863, + "value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length": 16864, + "format of the revert reason is given by the following regular expression": 16865, + "();\\n }\\n\\n ": 16866, + "1%": 16867, + "As ": 16868, + "Bound": 16869, + "CL": 16870, + "Dat": 16871, + "Gold": 16872, + "Squ": 16873, + "_type": 16874, + "_create": 16875, + "_tradingOpen": 16876, + "best ": 16877, + "ire": 16878, + "job": 16879, + "scan": 16880, + "x112": 16881, + "{Transfer} event": 16882, + "\\n @notice ": 16883, + "s must be ": 16884, + "s if the ": 16885, + "invocation": 16886, + ") // ": 16887, + "the return ": 16888, + ");\\r\\n ": 16889, + "\\\");\\n\\n ": 16890, + "is capp": 16891, + "ing then ": 16892, + "callback": 16893, + "return result": 16894, + " = ((": 16895, + "whom": 16896, + "whose ": 16897, + ") public only": 16898, + "fff": 16899, + "a storage ": 16900, + "(uint256 id": 16901, + "upscal": 16902, + "currentDay": 16903, + " is preser": 16904, + "totalSupply, and the ": 16905, + "logarithm": 16906, + "module": 16907, + "ed by totalSupply, and the ": 16908, + "Math._": 16909, + "/\\n /// ": 16910, + " for contracts ": 16911, + "baseToken": 16912, + "ved by": 16913, + "sum is preser": 16914, + "address,uint256,": 16915, + "es[msg.sender": 16916, + "signature.length == ": 16917, + "without any ": 16918, + "ENO": 16919, + "into a single ": 16920, + "nonReentrant(": 16921, + "at least 1 ": 16922, + "es the actual ": 16923, + ");\\n\\n function get": 16924, + "their": 16925, + "(_msgSender(), amount": 16926, + ", which can be ": 16927, + "PublicSale": 16928, + "Tokens > ": 16929, + "return true;\\n } else {\\n return ": 16930, + "stored in ": 16931, + ",\\r\\n uint256 amount\\r\\n ": 16932, + "////////////////////////////////////////////////////////": 16933, + "} from \\\"../": 16934, + "construction, since the code is only stored at the end": 16935, + "toString(": 16936, + "Withdrawn": 16937, + "root of the ": 16938, + "Cache the ": 16939, + "decrementing then ": 16940, + "dao": 16941, + ", \\\"SafeMath: multiplication overflow": 16942, + ", \\\"SafeMath: addition overflow": 16943, + "() external view returns (address);\\n function ": 16944, + "handl": 16945, + "balances is capp": 16946, + ").div(100": 16947, + "future ": 16948, + "compiler ": 16949, + "_initializing": 16950, + "uint24 extraData": 16951, + "FIELD": 16952, + "itself, ": 16953, + "keep in mind ": 16954, + ", which returns 0 for contracts ": 16955, + "registerAndSubscribe": 16956, + "class of ": 16957, + "Addition cannot overflow.\\n */\\n function ": 16958, + "move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this ": 16959, + "c / a == b, \\\"SafeMath: multiplication overflow": 16960, + ";\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {": 16961, + "the sum of all balances is capp": 16962, + "ed by totalSupply, and the sum is preser": 16963, + "move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId": 16964, + "the sum of all balances is capped by totalSupply, and the sum is preser": 16965, + "the sum of all balances is capped by totalSupply, and the sum is preserved by": 16966, + "\"pragma solidity ^": 16967, + "\"bytecode": 16968, + "(approvedAddress": 16969, + ".\\n * @param ": 16970, + "1 for ": 16971, + "3\\n// Creator: Chiru Labs\\n\\npragma solidity ^0.8.4": 16972, + "ALE": 16973, + "PUBLIC": 16974, + "SLOAD": 16975, + "tmp": 16976, + "y) internal pure returns (": 16977, + "in\\n // ": 16978, + ") virtual ": 16979, + ") returns (bool": 16980, + "ice ": 16981, + "amount.mul(": 16982, + "\\\");\\n }\\n\\n function ": 16983, + "address data ": 16984, + "er contract": 16985, + "Trade": 16986, + " = false": 16987, + ",\\n bytes32[] memory ": 16988, + "..255": 16989, + "onlyAdmin": 16990, + "0000 ": 16991, + "0.0": 16992, + ";\\n\\n// ": 16993, + "on a ": 16994, + "this point ": 16995, + "0xf": 16996, + "will always ": 16997, + ",\\n address spender,\\n uint256 value": 16998, + "utils/SafeERC20": 16999, + "ONENT": 17000, + "Hash\"": 17001, + "result, ": 17002, + "\\r\\n }\\r\\n ": 17003, + "refe": 17004, + "Solidity\\u0027": 17005, + "variable ": 17006, + "token/ERC20/utils/SafeERC20": 17007, + "For more ": 17008, + ")\\n mstore(": 17009, + "modules/": 17010, + "AccessControlEnumerable": 17011, + "packedOwnerships[tokenId": 17012, + "operation overflow": 17013, + "web": 17014, + "Art ": 17015, + "a / b;\\n }\\n\\n /**\\n * @dev Returns the ": 17016, + "_BE": 17017, + "calculate the ": 17018, + "increment the ": 17019, + "Mask of all ": 17020, + "[to].": 17021, + "snapshots": 17022, + "time of ": 17023, + "Append": 17024, + "charity": 17025, + " bits for `": 17026, + ", \\\"SafeMath: subtraction overflow": 17027, + " is Context, ERC165": 17028, + "during contract ": 17029, + ") - 1;\\n\\n // The bit position of `": 17030, + ";\\n\\n // The bit mask": 17031, + "needed to ": 17032, + "except through ": 17033, + "Overflow not possible: balance ": 17034, + "b5e1": 17035, + "total number of tokens in existence": 17036, + "`tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be ": 17037, + "FlashLoan": 17038, + "reeding": 17039, + "address signer = ECDSA.recover": 17040, + "OpenSea": 17041, + "checked above": 17042, + "IERC721 {\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\"": 17043, + "startTokenId + quantity": 17044, + "uint256) {\\n // Counter underflow is impossible as ": 17045, + "}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function ": 17046, + "DelegateVotesChanged": 17047, + "When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be ": 17048, + "\"// SPDX-License-Identifier: MIT\\n// ERC721A Contracts v4.2.3\\n// Creator: Chiru Labs\\n\\npragma solidity ^0.8.4": 17049, + "ERC721AStorage.layout().": 17050, + "IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\"": 17051, + "s with added overflow": 17052, + "Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be ": 17053, + "mostly ": 17054, + ":\\n *\\n * /^AccessControl: account (0x[0-9a-f]{": 17055, + ") public virtual override onlyRole(getRoleAdmin(role)) {\\n _": 17056, + "format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{": 17057, + "Addition cannot overflow.\\n */\\n function add": 17058, + "\"bytecodeHash\"": 17059, + "..255] `": 17060, + "Solidity\\u0027s `": 17061, + "Mask of all 256 bits ": 17062, + " downcasted) {\\n downcasted = int": 17063, + "\"G": 17064, + "',": 17065, + "),\\n ": 17066, + "Bid": 17067, + "Cut": 17068, + "Single": 17069, + "_PERMIT_TYPEHASH": 17070, + "_usd": 17071, + "flo": 17072, + "ial ": 17073, + "s >= ": 17074, + "int8": 17075, + "thir": 17076, + "tist ": 17077, + "incorrect ": 17078, + ", sub": 17079, + "entries": 17080, + "isor": 17081, + "Top": 17082, + "` restore": 17083, + "ing without ": 17084, + "contracts, ": 17085, + "InFor": 17086, + "ERC721TokenReceiver": 17087, + "memory, which can be ": 17088, + "it alway": 17089, + "true, the ": 17090, + "value and ": 17091, + "pos ": 17092, + "(uint256 new": 17093, + "min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a ": 17094, + ");\\n\\n _beforeTokenTransfer": 17095, + " is at most ": 17096, + "Signature ": 17097, + "off ": 17098, + "sellLiquidity": 17099, + "= _get": 17100, + "denomin": 17101, + "unchecked operations ": 17102, + "quantity * (": 17103, + "generate": 17104, + "https://eips.ethereum.org/EIPS/eip-2098": 17105, + "reverting the transaction ": 17106, + "stakeId": 17107, + "spender, newAllowance": 17108, + "zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {": 17109, + "Verify": 17110, + "Using this library ": 17111, + ") public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20": 17112, + " {\\n /**\\n * @dev Returns the addition": 17113, + "require(b > 0, errorMessage": 17114, + "multiplier": 17115, + "too much ": 17116, + ";\\n\\n /**\\n * @notice ": 17117, + ", which is checked above": 17118, + "totalSupply + amount": 17119, + "a - b;\\n }\\n\\n /**\\n * @dev Returns the ": 17120, + "ECDSA: invalid signature": 17121, + "(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint": 17122, + "s this int": 17123, + "secondary ": 17124, + "Enabled = false": 17125, + "operator, approved);\\n }\\n\\n /**\\n * @dev ": 17126, + "+ amount is at most ": 17127, + "bugs, so ": 17128, + "Trigg": 17129, + "DigitalMedia": 17130, + "MintAmountPerTx": 17131, + "gobbler": 17132, + "ributor": 17133, + "on overflow. This ": 17134, + "individual ": 17135, + "iddenMetadataUri": 17136, + "str := sub(str": 17137, + "CannotBe": 17138, + "[to] += quantity * (": 17139, + "global_collateral_ratio": 17140, + "BankX": 17141, + "benefit is lost if 'b' is also tested": 17142, + "did not succeed": 17143, + "recommended to use it alway": 17144, + "instead of the unchecked operations ": 17145, + "eliminates an ": 17146, + "At(address registrant, uint256 index) external returns (": 17147, + "class of bugs, so ": 17148, + "a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting ": 17149, + "Overflow not possible: balance + amount is at most ": 17150, + "b5e139f": 17151, + "` restores this int": 17152, + "reverting the transaction when ": 17153, + "Using this library instead of the unchecked operations ": 17154, + "totalSupply + amount, which is checked above": 17155, + "eliminates an entire": 17156, + "Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above": 17157, + "Using this library instead of the unchecked operations eliminates an entire": 17158, + "#((": 17159, + ".\\n * ": 17160, + "Vot": 17161, + "_p": 17162, + "_cap": 17163, + "s owned by ": 17164, + "on\"": 17165, + "\\n )\\n {\\n ": 17166, + "the signature ": 17167, + "ently ": 17168, + "quite ": 17169, + "vers": 17170, + "owner.\\n // - `startTimestamp` to the timestamp of ": 17171, + ": Cannot ": 17172, + " // If the next slot is within bounds.": 17173, + "\\n\\n/**\\n * @dev ": 17174, + "--- ": 17175, + "not the ": 17176, + "Amount of ": 17177, + ");\\n\\n uint256 ": 17178, + "if (ownership.addr != address(0)": 17179, + "class": 17180, + "will not be ": 17181, + "times ": 17182, + "string memory _name": 17183, + "buyLiquidity": 17184, + "Fees[0": 17185, + ")));\\r\\n ": 17186, + "s to the ": 17187, + "......": 17188, + " <0.9.0": 17189, + "storing the ": 17190, + ", amounts": 17191, + "OperatorNot": 17192, + "present.\\n */\\n function _": 17193, + "MINATOR": 17194, + "mutability ": 17195, + "<= totalSupply": 17196, + "2691": 17197, + "functions marked ": 17198, + "packed = (": 17199, + "definition": 17200, + "withdraw ": 17201, + "messag": 17202, + "uint64 _": 17203, + "s[tokenId].": 17204, + "compound ": 17205, + " of two unsigned integers, reverting on\\n * overflow (when the ": 17206, + "distributor": 17207, + "differ": 17208, + "}\\n\\n // Underflow of the sender's balance is impossible because we check for\\n // ownership above and the recipient's balance can't realistically overflow.\\n // Counter overflow is incredibly unrealistic as ": 17209, + "making it ": 17210, + "MaxWalletLimit": 17211, + "CopyEntries": 17212, + ", uint256 index) internal view returns (": 17213, + "mapping (address => uint256": 17214, + "It is possible to ": 17215, + "random ": 17216, + ");\\n\\n _currentIndex = ": 17217, + "false otherwise": 17218, + ";\\r\\n }\\r\\n ": 17219, + "state mutability ": 17220, + "ence state mutability ": 17221, + " == 0) {\\n uint256 nextTokenId = tokenId + 1": 17222, + "Compute ": 17223, + "transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) public virtual override {\\n ": 17224, + "obtain the ": 17225, + "significant": 17226, + "Fees[1": 17227, + "for each mint": 17228, + "total number of tokens minted": 17229, + "`hashes": 17230, + "\\\\ \\\\": 17231, + ".\\n if (prevOwnershipPacked ": 17232, + "(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n require(b > 0, errorMessage": 17233, + "_packedOwnerships[nextTokenId] == 0) {\\n ": 17234, + "registerAndCopyEntries": 17235, + "Updates:\\n // - `address` to the ": 17236, + "name, symbol": 17237, + "render the ": 17238, + ";\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the ": 17239, + "Failed(": 17240, + "iteral": 17241, + "DELEGATION_TYPEHASH": 17242, + "_FEE_PERCENT": 17243, + "_startTokenId();\\n }\\n }\\n\\n /**\\n * @dev Returns the ": 17244, + ",\\n uint256[] memory balances,\\n uint256 ": 17245, + ";\\n // If the next slot's address is zero and not burned (i.e. packed value is zero).": 17246, + "String operations.\\n */\\nlibrary Strings {\\n bytes16 private constant _HEX_SYMBOLS = \\\"0123456789abcdef\\\"": 17247, + "relevant ": 17248, + "delete _tokenApprovals[tokenId]": 17249, + "warning without ": 17250, + "burnt": 17251, + "nested ": 17252, + "\\n *\\n * Requirements:\\n *\\n * - `": 17253, + ") {\\n // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.": 17254, + "auxiliary data for `owner`. (e.g. number of whitelist mint slots used": 17255, + "recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount": 17256, + "If the next slot may not have been initialized (i.e. `nextInitialized == false`) .\\n if (prevOwnershipPacked ": 17257, + "Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension": 17258, + "_packedOwnerships[nextTokenId] = prevOwnershipPacked;\\n }\\n }\\n }\\n ": 17259, + "ENOMINATOR": 17260, + "return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev ": 17261, + ",\\n address spender,\\n uint256 value\\n ) internal {\\n ": 17262, + " // If the next slot is within bounds.\\n ": 17263, + "ence state mutability warning without ": 17264, + " == 0) {\\n uint256 nextTokenId = tokenId + 1;\\n // If the next slot's address is zero and not burned (i.e. packed value is zero).": 17265, + "_packedOwnerships[nextTokenId] == 0) {\\n // If the next slot is within bounds.\\n ": 17266, + ";\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative": 17267, + ") {\\n // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.\\n ": 17268, + "ence state mutability warning without generating ": 17269, + " == 0) {\\n uint256 nextTokenId = tokenId + 1;\\n // If the next slot's address is zero and not burned (i.e. packed value is zero).\\n if (": 17270, + "()\\n ": 17271, + "() internal view ": 17272, + "(digest": 17273, + ")` is ": 17274, + "-> ": 17275, + "@member ": 17276, + "COL": 17277, + "DOMAIN": 17278, + "N_CO": 17279, + "_bytes": 17280, + "cash": 17281, + "ih": 17282, + "ju": 17283, + "|= ": 17284, + "ency ": 17285, + ", gt(": 17286, + "unlocked": 17287, + "exchange ": 17288, + "amount to ": 17289, + "Token.": 17290, + " IERC721Metadata": 17291, + "account, ": 17292, + "transferFee": 17293, + "an un": 17294, + "(address _owner": 17295, + "setMax": 17296, + ";\\n bool ": 17297, + "\\r\\n\\r\\n ": 17298, + "by setting ": 17299, + "minting.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `": 17300, + "Role ": 17301, + "bytes32 digest ": 17302, + "IPIENT": 17303, + "(\\n address _": 17304, + "SafeMath {\\n /**\\n * @dev Returns the addition": 17305, + "fees = ": 17306, + "Burnable is ": 17307, + "NotPaused(": 17308, + "Delta": 17309, + "\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\"": 17310, + "marketingTax": 17311, + ";\\n\\n // Mask of all 256 bits ": 17312, + "address,uint": 17313, + ") internal view virtual returns (bool) {\\n return ": 17314, + ";\\n }\\n ": 17315, + ";\\n }\\n ": 17316, + ".\\n */\\ncontract ": 17317, + ") / 2 ": 17318, + "no data": 17319, + "Blocks": 17320, + "tokenId < _": 17321, + "_totalFees": 17322, + "$$ ": 17323, + " IERC165": 17324, + "inheriting ": 17325, + "sqrtRatio": 17326, + "(address(0), to, updatedIndex": 17327, + "equal ": 17328, + "description": 17329, + "_packedOwnershipOf": 17330, + "WARNING: This ": 17331, + "Transfer(address indexed from, address indexed to, uint256 value": 17332, + "\\n // - [0..": 17333, + "computedHash = ": 17334, + ".safeTransfer(": 17335, + "get the total number of tokens minted": 17336, + "reduce the count": 17337, + "NOT_ENTERED = 1": 17338, + "An event ": 17339, + "`.\\n // - `numberMinted += quantity": 17340, + ")\\n external\\n payable": 17341, + "uint160(addr": 17342, + "> 0) {\\n return ": 17343, + "ZERO_ADDRESS": 17344, + "(\\n address owner,\\n address spender,\\n uint256 amount\\n ) internal virtual {\\n uint256 currentAllowance = allowance(owner, spender);\\n if (currentAllowance != type(uint256).max) {\\n require(currentAllowance >= amount, \\\"ERC20: insufficient allowance\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - amount);\\n }\\n }\\n }\\n\\n /**\\n * @dev ": 17345, + "keccak256(bytes(name": 17346, + "factory ": 17347, + "IERC721Receiver(to).onERC721Received.selector": 17348, + "_totalSupply -= amount;\\n\\n emit Transfer": 17349, + "`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to ": 17350, + "+= quantity`.\\n // - `numberMinted += quantity": 17351, + "Burned tokens will ": 17352, + "ENTERED = 2": 17353, + ".\\n // - `startTimestamp` to the timestamp of minting.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `": 17354, + "Updates:\\n // - `address` to the owner": 17355, + "dynamic": 17356, + ". Also ": 17357, + "frax_": 17358, + "s = 0;\\n uint256 ": 17359, + "`.\\n //\\n // We can directly add to the ": 17360, + ".\\n // The ": 17361, + "Address for address;\\n using Strings for uint256": 17362, + "\"_transfer:: Transfer Delay enabled. Only one purchase ": 17363, + "freeMemoryPointer": 17364, + "(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function ": 17365, + "Bits Layout:\\n // - [0..": 17366, + "of `tokenId`.\\n */\\n function _": 17367, + "BITPOS_NUMBER_MINTED) | 1);\\n\\n // ": 17368, + "next token ID to be minted": 17369, + "recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-": 17370, + "get the total number of tokens minted, please ": 17371, + "+= quantity`.\\n // - `numberMinted += quantity`.\\n //\\n // We can directly add to the ": 17372, + "Burned tokens will reduce the count": 17373, + ".\\n // - `startTimestamp` to the timestamp of minting.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `quantity == 1": 17374, + "Updates:\\n // - `address` to the owner.\\n // - `startTimestamp` to the timestamp of minting.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `quantity == 1": 17375, + "\"_transfer:: Transfer Delay enabled. Only one purchase per block allowed.\"": 17376, + "\"Amount ": 17377, + "\"Insufficient ": 17378, + ".WETH": 17379, + "1 - ": 17380, + "2-": 17381, + "5._": 17382, + "DC": 17383, + "OFFSET": 17384, + "_at": 17385, + "_ = ": 17386, + "_require(": 17387, + "`msgSender": 17388, + "`msg.sender": 17389, + "a2": 17390, + "ject to ": 17391, + "us the ": 17392, + "xn": 17393, + "\\n*/\\n function ": 17394, + "e to ": 17395, + "s may ": 17396, + "include ": 17397, + "ated by ": 17398, + "\\\"main ": 17399, + "function may ": 17400, + "20+ ": 17401, + "call the ": 17402, + "ifs save ": 17403, + ");\\n }\\n return ": 17404, + "for (uint ": 17405, + "if approvedAddress ": 17406, + "parti": 17407, + "redund": 17408, + "maxWallet ": 17409, + "The divisor cannot be ": 17410, + "uniswapV2Router ": 17411, + "buyer": 17412, + "data version of {": 17413, + "If there are ": 17414, + "64})$/": 17415, + "██╗": 17416, + ");\\n } else {\\n ": 17417, + ".\\n return (": 17418, + "Stash": 17419, + ", bool filtered": 17420, + "gas over a ": 17421, + "< stop": 17422, + "AccessControl-": 17423, + "? leaves[": 17424, + "fully ": 17425, + "40}) is missing role (0x[0-9a-f]{": 17426, + "ownership data ": 17427, + ") {\\n return _unpackedOwnership": 17428, + "boolean": 17429, + ");\\r\\n }\\r\\n\\r\\n /**\\r\\n * @dev Returns the ": 17430, + "boolean condition": 17431, + ".sol\\\";\\n\\ninterface ": 17432, + "leafPos++] : ": 17433, + "extraDataCasted ": 17434, + ") {\\n _require": 17435, + "on\\n * overflow (when the result is negative": 17436, + ".sol\\\";\\nimport \\\"../../utils/introspection/ERC165.sol\\\";\\n\\n/**\\n * @dev ": 17437, + ");\\r\\n\\r\\n // ": 17438, + "(to, amount": 17439, + "\\n uint256 size": 17440, + "maximum limit of ": 17441, + "them into a ": 17442, + "bounded ": 17443, + "around 20+ ": 17444, + ".\\n *\\n * Emits a {Transfer} event for each mint": 17445, + "accountBalance <= totalSupply": 17446, + "get the next ": 17447, + "` with assembly to avoid ": 17448, + "extra SLOAD": 17449, + "two numbers. The result is rounded toward": 17450, + "totalHashes ": 17451, + "approvedAddressSlot, 0": 17452, + ")\\n internal\\n pure": 17453, + "(address sender, address recipient, uint256 amount) external returns (bool": 17454, + "Pos++];\\n ": 17455, + "eq(msgSender": 17456, + "ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ": 17457, + ".length == 0) {\\n ": 17458, + "amount <= accountBalance <= totalSupply": 17459, + ", so we distribute": 17460, + "wrap ": 17461, + "Keep ": 17462, + "View": 17463, + "hashes[hash": 17464, + "extraData = uint24(": 17465, + "leavesLen ? leaves[": 17466, + " of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative": 17467, + "s < leavesLen ? leaves[": 17468, + "\\r\\n /**\\r\\n * @dev ": 17469, + "TokenOwnership memory) {\\n return _unpackedOwnership": 17470, + "pack them into a ": 17471, + "nextInitializedFlag(quantity": 17472, + "IERC721Receiver(to).onERC721Received(_msgSender(), ": 17473, + "Consumer": 17474, + "sstore(approvedAddressSlot, 0": 17475, + "This is equivalent to `delete _tokenApprovals[tokenId]": 17476, + "isApprovedForAll(from, _msgSenderERC721A())": 17477, + "leafPos < leavesLen ? leaves[": 17478, + ";\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\\n * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\\n * by default, can be ": 17479, + "EnumerableSet for ": 17480, + "minutes": 17481, + "Parameter": 17482, + ";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = _HEX_SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n}\\n\"": 17483, + ")\\r\\n external\\r\\n ": 17484, + "Multiplication cannot overflow.\\n */\\n function ": 17485, + "extra data for the ": 17486, + "effectively ": 17487, + "Rigid": 17488, + "Squeeth": 17489, + "{Transfer} event(": 17490, + "compound boolean condition": 17491, + "nested ifs save ": 17492, + "_packedOwnerships[nextTokenId] = prevOwnershipPacked;\\n }\\n }\\n }\\n }\\n\\n emit Transfer": 17493, + ") / 2 can overflow": 17494, + "\\\"main queue": 17495, + "redundant ": 17496, + "The divisor cannot be zero": 17497, + "gas over a compound boolean condition": 17498, + "40}) is missing role (0x[0-9a-f]{64})$/": 17499, + "leafPos++] : hashes[hash": 17500, + "around 20+ gas over a compound boolean condition": 17501, + "` with assembly to avoid redundant ": 17502, + "leafPos < leavesLen ? leaves[leafPos++] : hashes[hash": 17503, + "nested ifs save around 20+ gas over a compound boolean condition": 17504, + ".openzeppelin.com/": 17505, + "0)": 17506, + "Fr": 17507, + "IRE": 17508, + "_ ": 17509, + "vrf": 17510, + "zro": 17511, + ", \\u0027": 17512, + "\\\");\\n }\\n\\n /**\\n * @dev Returns the ": 17513, + ") {\\r\\n ": 17514, + "Ref ": 17515, + "call is not ": 17516, + "(address _to": 17517, + ") internal onlyInitializ": 17518, + "from another ": 17519, + "contract address": 17520, + "max(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a ": 17521, + "The nested ifs save around 20+ gas over a compound boolean condition": 17522, + "with no ": 17523, + "this imp": 17524, + "this from ": 17525, + "@@@@@@@": 17526, + "Delight": 17527, + "but in ": 17528, + "sibling ": 17529, + ");\\n require(": 17530, + "if the target address ": 17531, + ";\\n }\\n }\\n ": 17532, + "Developers ": 17533, + "special": 17534, + "projectId ": 17535, + "call to nonReentrant": 17536, + " = _startTokenId": 17537, + "(msg.sender, amount": 17538, + "ERC20 token ": 17539, + "_checkFilterOperator": 17540, + "via the ": 17541, + "3525": 17542, + "basic": 17543, + "Finance": 17544, + "specified": 17545, + "sales": 17546, + "ffffffffffffffffffffffff": 17547, + "SignedMath": 17548, + "identifier ": 17549, + "ILayerZero": 17550, + " = new address[](": 17551, + "multiple variables": 17552, + "do {\\n ": 17553, + "() public pure returns (": 17554, + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n uint256 c = a + b": 17555, + "set of permission": 17556, + ".\\r\\n *\\r\\n * ": 17557, + "Ptr, ": 17558, + "(address addr) internal pure returns (": 17559, + "//\\n// ": 17560, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/": 17561, + ";\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (": 17562, + "_LENGTH = 20": 17563, + "leavesLen": 17564, + ", please pack them into a ": 17565, + "likel": 17566, + "\\\"Hack": 17567, + ")), _ADDRESS_LENGTH": 17568, + "LzApp": 17569, + "ADDRESS_LENGTH = 20": 17570, + ") || (": 17571, + "toHexString(uint256(uint160(addr": 17572, + "executed if the target address ": 17573, + "in\\n // construction, since the code is only stored at the end": 17574, + ".swapExact": 17575, + "uint8 private constant _ADDRESS_LENGTH = 20": 17576, + "\\n }\\n packed = (": 17577, + "return\\n interfaceId == type(IERC721": 17578, + "sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s ": 17579, + ".\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ": 17580, + "Minimal": 17581, + "when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod": 17582, + ", which returns 0 for contracts in\\n // construction, since the code is only stored at the end": 17583, + "BITPOS_NUMBER_MINTED) | 1);\\n\\n // Updates:\\n // - `address` to the owner.\\n // - `startTimestamp` to the timestamp of minting.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `quantity == 1": 17584, + "If there are multiple variables": 17585, + "Multiplication cannot overflow.\\n */\\n function mul": 17586, + "call is not executed if the target address ": 17587, + "toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH": 17588, + "sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom": 17589, + ", which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // ": 17590, + "If there are multiple variables, please pack them into a ": 17591, + "call is not executed if the target address is not ": 17592, + "\"useL": 17593, + "-level ": 17594, + ".:": 17595, + ".proxy.": 17596, + "1]": 17597, + "3 * ": 17598, + "@inheritdoc ": 17599, + "Filte": 17600, + "Now ": 17601, + "_OPERATOR_FILTER_REGISTRY": 17602, + "_modules/": 17603, + "av": 17604, + " | ": 17605, + "one. ": 17606, + "uncallable if the ": 17607, + "unbounded ": 17608, + "//solhint-disable-next-line max-line-length\\n require(": 17609, + ") || ": 17610, + "end = ": 17611, + "ed ASCII `string` ": 17612, + "` function that ": 17613, + "owner == address(0)) revert ": 17614, + "of data ": 17615, + ".\\n *\\n * May emit a {Role": 17616, + "- see https://github.com/ethereum/solidity/issues/": 17617, + "external, and ": 17618, + "es too much ": 17619, + ") {\\n (bool success, bytes memory returndata) = target": 17620, + "not check": 17621, + "view accessor": 17622, + "it as part of a ": 17623, + "memory consum": 17624, + " of 20 bytes ": 17625, + "true`.\\n _": 17626, + "value once ": 17627, + "(uint256 approvedAddressSlot, address approvedAddress": 17628, + "token in the ": 17629, + "this; // ": 17630, + "Calling a ": 17631, + "(\\n bytes32[] memory proof": 17632, + "\\n // currently is to use assembly": 17633, + "will copy the ": 17634, + ") {\\n bytes32 r": 17635, + "and\\n // ": 17636, + "private` function that ": 17637, + ";\\n mapping(uint256 => ": 17638, + "does the actual ": 17639, + "One": 17640, + "On the first ": 17641, + "red (see": 17642, + ");\\n\\n /**\\n * @dev Returns a token ID ": 17643, + "\\n */\\n\\n": 17644, + "since no data": 17645, + "Interface(": 17646, + "set in an ": 17647, + "set grow": 17648, + "type that ": 17649, + ".\\n * Burned tokens will reduce the count": 17650, + "is not supported. ": 17651, + "using it as part of a ": 17652, + "\\n\\t\\t// ": 17653, + ", and using it as part of a ": 17654, + ");\\n\\t\\t": 17655, + "() external view returns (uint);\\n function ": 17656, + "s a contract from ": 17657, + "Moves ": 17658, + "safeTransferFrom}": 17659, + "should keep in mind ": 17660, + "updateMaxWalletAmount": 17661, + "RateProvider": 17662, + "1 {": 17663, + "ing the `nonReentrant` function ": 17664, + "\\n *\\n * WARNING: This ": 17665, + "gas fees. ": 17666, + "https://eips.ethereum.org/EIPS/eip-22": 17667, + ")\\n );\\n\\n // ": 17668, + "approved query for nonexistent token": 17669, + "fulfillRandom": 17670, + "_buyMarketingFee": 17671, + "DelegateChanged": 17672, + "Order": 17673, + "operation will copy the ": 17674, + "array\\n *\\n * WARNING: This ": 17675, + "this function has an ": 17676, + "safeMint(address to, uint256 tokenId": 17677, + "(0x7": 17678, + ") external view returns (uint256);\\n}\\n\"": 17679, + "currentAllowance - amount": 17680, + "PublicDrop": 17681, + "after this point ": 17682, + "weiValue": 17683, + "where copy": 17684, + "} that allows ": 17685, + ") {\\n return (address(0), RecoverError.InvalidSignature": 17686, + "fit in a block": 17687, + ",\\n \\\"ERC721: ": 17688, + "calling itself, ": 17689, + "ing to memory consum": 17690, + "query the ": 17691, + "prevent this from ": 17692, + "calls to nonReentrant ": 17693, + ". This is design": 17694, + "ownership.burned ": 17695, + "cost, and using it as part of a ": 17696, + "By storing the ": 17697, + "ProtocolFees": 17698, + "(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {\\n require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(to != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, amount);\\n\\n uint256 fromBalance = _balances[from];\\n require(fromBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n unchecked {\\n _balances[from] = fromBalance - amount": 17699, + "again, a ": 17700, + "division of ": 17701, + "set, value": 17702, + ";\\n // Cast ": 17703, + "Return the entire ": 17704, + "`nonReentrant`": 17705, + "point where copy": 17706, + "would like ": 17707, + "))\\n v": 17708, + "Returns an array of ": 17709, + "toInt256": 17710, + "square": 17711, + "freeze": 17712, + ") - 1;\\n\\n // The ": 17713, + "() external pure returns (string memory": 17714, + "` with fixed length": 17715, + ";\\n // ecrecover takes the signature parameters, and the only way to get them": 17716, + "amples": 17717, + "original value once ": 17718, + "entire storage to ": 17719, + "refund is trigge": 17720, + "vestingRound": 17721, + "(0, since no data": 17722, + "that\\n * this function has an ": 17723, + "node_modules/": 17724, + "Expir": 17725, + "Prevents a contract from ": 17726, + "in the set. O(1).\\n */\\n function length(": 17727, + "Equivalent to `safeTransferFrom(from, to, tokenId, ''": 17728, + "keccak256(abi.encodePacked(\\\"\\\\x19\\\\x01": 17729, + ");\\n\\n // Clear approvals from the previous owner.\\n assembly {\\n ": 17730, + "\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.6.0 <0.8.0;\\n\\n/**\\n * @dev ": 17731, + "0x5b5e139f": 17732, + "constructor execution.\\n\\n uint256 size": 17733, + "proportion": 17734, + "tokensOfOwnerIn": 17735, + "`.\\n sstore(approvedAddressSlot, 0": 17736, + "OpenSea ": 17737, + "\\n\\t *\\n\\t * @dev ": 17738, + "`nonReentrant` function from another ": 17739, + "packed & _BITMASK_BURNED": 17740, + "of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a ": 17741, + "to its not check": 17742, + "by making the `nonReentrant` function ": 17743, + "queried without any ": 17744, + "Allowance = token.allowance(address(this), spender": 17745, + "Override": 17746, + "`address` with fixed length": 17747, + ")\\n }\\n }\\n\\n // Underflow of the sender's balance is impossible because we check for\\n // ownership above and the recipient's balance can't realistically overflow.\\n // Counter overflow is incredibly unrealistic as ": 17748, + "s that are queried without any ": 17749, + "Any calls to nonReentrant ": 17750, + "bytecode - see https://github.com/ethereum/solidity/issues/": 17751, + "Content\"": 17752, + "silence state mutability warning without generating ": 17753, + "Casted;\\n // Cast ": 17754, + "_36_": 17755, + "Inheriting ": 17756, + ") | _nextExtraData(address(0), to, ": 17757, + "on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div": 17758, + ");\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(": 17759, + "if (nextTokenId != _currentIndex) {\\n // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.\\n ": 17760, + "_EXPONENT": 17761, + "to` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address to, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _transfer(owner, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``from``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 amount\\n ": 17762, + "\\\",\\n Strings.": 17763, + "s to a point where copy": 17764, + "function\\n * uncallable if the ": 17765, + "\\n _revert(returndata, errorMessage": 17766, + "analys": 17767, + "LiquidityPairTokens": 17768, + "state-changing function may ": 17769, + "TakeFee": 17770, + ", from, _msgSenderERC721A())": 17771, + "images are ": 17772, + "_transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) public virtual override {\\n ": 17773, + "summed ASCII `string` ": 17774, + "gas to fit in a block": 17775, + "ed\\n * to mostly ": 17776, + "https://eips.ethereum.org/EIPS/eip-712#definition": 17777, + "be used by view accessor": 17778, + "approxim": 17779, + "expensive. This is design": 17780, + "masking.\\n assembly {\\n ": 17781, + "(approvedAddress, from, _msgSenderERC721A())": 17782, + ",\\n bytes32[] memory leaves": 17783, + "total number of tokens in existence.\\n * Burned tokens will reduce the count": 17784, + "format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/": 17785, + "memory, which can be quite ": 17786, + "It is possible to prevent this from ": 17787, + "render the function\\n * uncallable if the ": 17788, + "iteralContent\"": 17789, + "_packedOwnerships[nextTokenId] == 0) {\\n // If the next slot is within bounds.\\n if (nextTokenId != _currentIndex) {\\n // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.\\n ": 17790, + " == 0) {\\n uint256 nextTokenId = tokenId + 1;\\n // If the next slot's address is zero and not burned (i.e. packed value is zero).\\n if (_packedOwnerships[nextTokenId] == 0) {\\n // If the next slot is within bounds.\\n if (nextTokenId != _currentIndex) {\\n // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.\\n ": 17791, + "ihood ": 17792, + "nextInitializedFlag(quantity) | _nextExtraData(address(0), to, ": 17793, + "This is equivalent to `delete _tokenApprovals[tokenId]`.\\n sstore(approvedAddressSlot, 0": 17794, + "` with assembly to avoid redundant masking.\\n assembly {\\n ": 17795, + "Developers should keep in mind ": 17796, + "call to nonReentrant, _": 17797, + "likelihood ": 17798, + ", which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size": 17799, + "\"useLiteralContent\"": 17800, + "unbounded cost, and using it as part of a ": 17801, + "of data (0, since no data": 17802, + "es too much gas to fit in a block": 17803, + " of 20 bytes to its not check": 17804, + "true`.\\n _packedOwnerships[tokenId": 17805, + "(uint256 approvedAddressSlot, address approvedAddress) = _": 17806, + "this; // silence state mutability warning without generating ": 17807, + "Calling a `nonReentrant` function from another ": 17808, + "\\n // currently is to use assembly.\\n ": 17809, + ") {\\n bytes32 r;\\n ": 17810, + "private` function that does the actual ": 17811, + "On the first call to nonReentrant, _": 17812, + "set in an array\\n *\\n * WARNING: This ": 17813, + "set grows to a point where copy": 17814, + "is not supported. It is possible to prevent this from ": 17815, + "gas fees. Developers should keep in mind ": 17816, + "https://eips.ethereum.org/EIPS/eip-2200": 17817, + "operation will copy the entire storage to ": 17818, + "after this point will fail": 17819, + "calling itself, directly or indirectly": 17820, + "ing to memory consumes too much gas to fit in a block": 17821, + "By storing the original value once ": 17822, + "again, a refund is trigge": 17823, + "Return the entire set in an array\\n *\\n * WARNING: This ": 17824, + ";\\n // ecrecover takes the signature parameters, and the only way to get them\\n // currently is to use assembly.\\n ": 17825, + "that\\n * this function has an unbounded cost, and using it as part of a ": 17826, + "Prevents a contract from calling itself, directly or indirectly": 17827, + "Equivalent to `safeTransferFrom(from, to, tokenId, '')": 17828, + ");\\n\\n // Clear approvals from the previous owner.\\n assembly {\\n if approvedAddress ": 17829, + "by making the `nonReentrant` function external, and ": 17830, + "`address` with fixed length of 20 bytes to its not check": 17831, + "s that are queried without any gas fees. Developers should keep in mind ": 17832, + "Any calls to nonReentrant after this point will fail": 17833, + "bytecode - see https://github.com/ethereum/solidity/issues/2691": 17834, + "state-changing function may render the function\\n * uncallable if the ": 17835, + "summed ASCII `string` hexadecim": 17836, + "ed\\n * to mostly be used by view accessor": 17837, + "https://eips.ethereum.org/EIPS/eip-712#definition-of-": 17838, + "expensive. This is designed\\n * to mostly be used by view accessor": 17839, + "memory, which can be quite expensive. This is designed\\n * to mostly be used by view accessor": 17840, + "This is equivalent to `delete _tokenApprovals[tokenId]`.\\n sstore(approvedAddressSlot, 0)\\n }\\n }\\n\\n // Underflow of the sender's balance is impossible because we check for\\n // ownership above and the recipient's balance can't realistically overflow.\\n // Counter overflow is incredibly unrealistic as ": 17841, + "of data (0, since no data).": 17842, + "this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691": 17843, + "Calling a `nonReentrant` function from another `nonReentrant`": 17844, + "private` function that does the actual work": 17845, + "set grows to a point where copying to memory consumes too much gas to fit in a block": 17846, + "is not supported. It is possible to prevent this from happen": 17847, + "operation will copy the entire storage to memory, which can be quite expensive. This is designed\\n * to mostly be used by view accessor": 17848, + "By storing the original value once again, a refund is trigge": 17849, + "Return the entire set in an array\\n *\\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\\n * to mostly be used by view accessor": 17850, + "that\\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\\n * uncallable if the ": 17851, + "`address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecim": 17852, + "s that are queried without any gas fees. Developers should keep in mind that\\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\\n * uncallable if the ": 17853, + "By storing the original value once again, a refund is triggered (see": 17854, + "Return the entire set in an array\\n *\\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\\n * uncallable if the ": 17855, + "Return the entire set in an array\\n *\\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block": 17856, + "1in": 17857, + "86": 17858, + "? _": 17859, + "AMin,\\n uint amount": 17860, + "Fra": 17861, + "Mk": 17862, + "[token": 17863, + "[ERC2309": 17864, + "_adapter": 17865, + "cri": 17866, + "e5": 17867, + "t1": 17868, + "}.\\n *\\n * Requirements:\\n *\\n * - ": 17869, + "▀▀": 17870, + "nth": 17871, + "intial": 17872, + "debt": 17873, + "the address ": 17874, + "amounts ": 17875, + "to keep ": 17876, + "owner()": 17877, + "001": 17878, + ": https://": 17879, + "ipant": 17880, + "transferpercent": 17881, + "ifold": 17882, + "if(_": 17883, + "shutdown": 17884, + "es on the ": 17885, + "totalAsset": 17886, + "lied": 17887, + "beacon": 17888, + "contract implements the ": 17889, + "maxBatch": 17890, + "burner": 17891, + "can easily ": 17892, + " ": 17893, + "\\n @member ": 17894, + "uint public ": 17895, + "com/": 17896, + "\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.7.0": 17897, + "transferFrom(from, to, tokenId": 17898, + "`tokenId` would have to be 2**256": 17899, + "pairFor": 17900, + "subtrac": 17901, + ")\\\"))": 17902, + "_burn(_msgSender(), amount": 17903, + "allowedSeaDrop": 17904, + "approve caller is not owner nor ": 17905, + "approval ": 17906, + "Used": 17907, + "owner := and": 17908, + "delegates[": 17909, + "then add": 17910, + "modifier onlyOwner(": 17911, + "string memory) {\\n return _symbol": 17912, + "string memory) {\\n return _name": 17913, + "up a ": 17914, + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard ": 17915, + ",\\n uint amountAMin,\\n uint amount": 17916, + "UNCTION": 17917, + "keccak256(bytes": 17918, + ", r, vs": 17919, + "netSy": 17920, + "ized ownership slot": 17921, + "dave/": 17922, + ".\\r\\n */\\r\\n": 17923, + "Emits an {Approval} event indicating the updated allowance": 17924, + "uint96 feeNumerator": 17925, + "[account] = ": 17926, + ".sol';\\nimport './": 17927, + "packedOwnerships[startTokenId": 17928, + "`.\\n _packedOwnerships[startTokenId": 17929, + ");\\n }\\n\\n /**\\n * @notice ": 17930, + "math/Math.sol\"": 17931, + "](https://eips.ethereum.org/EIPS/eip-2": 17932, + " {\\n using SafeMath for uint256": 17933, + "╠╠╠╠": 17934, + "_callOptionalReturn(token, abi.encodeWithSelector(token.": 17935, + "midd": 17936, + "uint112 reserve1": 17937, + "_hdrn": 17938, + "Left": 17939, + "log_2": 17940, + "UpgradeabilityProxy": 17941, + "address(uniswapV2Router), ": 17942, + ".\\n * To get the total number of tokens minted, please ": 17943, + "Mask `owner": 17944, + "0x000000000000000000000000000000000000dEaD": 17945, + "OpenZeppelin Contracts guidelines: functions revert\\n * instead returning `false` on failure. This behavior is nonetheless\\n * conventional and does not conflict with the expectations of ERC20\\n * applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping(address => uint256) private _balances;\\n\\n mapping(address => mapping(address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The default value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5.05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address to, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _transfer(owner, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``from``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 amount\\n ": 17946, + "tokensIntoLiquidity": 17947, + "Internal function to invoke {IERC721Receiver-onERC721Received} on a target address": 17948, + "\\\\xe3\\\\x82\\\\x8": 17949, + "math utilities missing in the Solidity language.\\n */\\nlibrary Math": 17950, + "&& to != ": 17951, + "_dollar_value_d18": 17952, + "String operations.\\n */\\nlibrary Strings {\\n bytes16 private constant _HEX_SYMBOLS = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = _HEX_SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n}\\n\"": 17953, + "an unintial": 17954, + "total number of tokens in existence.\\n * Burned tokens will reduce the count.\\n * To get the total number of tokens minted, please ": 17955, + "[ERC2309](https://eips.ethereum.org/EIPS/eip-2": 17956, + "approve caller is not owner nor approved for all": 17957, + ",\\n uint amountAMin,\\n uint amountB": 17958, + "an unintialized ownership slot": 17959, + "[ERC2309](https://eips.ethereum.org/EIPS/eip-2309": 17960, + "();\\r\\n ": 17961, + "));": 17962, + ",\\r\\n ": 17963, + ".toUint": 17964, + "4/": 17965, + "Doc": 17966, + "FEE": 17967, + "Ic": 17968, + "Now": 17969, + "_uniswapV2Pair": 17970, + "_NOT_ENTERED": 17971, + "lt": 17972, + "{value: ": 17973, + "s & ": 17974, + "int16": 17975, + ", delegatee": 17976, + "tron": 17977, + "tokens (": 17978, + "isCodeHash": 17979, + "ERS": 17980, + "left ": 17981, + "in {": 17982, + ";\\n string ": 17983, + "tain": 17984, + "on every ": 17985, + "atures": 17986, + "tokens to be ": 17987, + "this point": 17988, + "fork": 17989, + "\\n // https://eips.ethereum.org/EIPS/eip-2200": 17990, + "ize the ": 17991, + "buypercent": 17992, + "(_totalSupply": 17993, + "possi": 17994, + "sellpercent": 17995, + "0, uint amount1": 17996, + "color": 17997, + ".\\n * Calling a `nonReentrant` function from another `nonReentrant`": 17998, + "balance query for ": 17999, + "in the same ": 18000, + " <= _": 18001, + "call a\\n * `": 18002, + "ROY": 18003, + "░░░": 18004, + " {\\n struct ": 18005, + "denominator == ": 18006, + "poolInfo": 18007, + "travers": 18008, + "downscale": 18009, + "Delegates ": 18010, + ",\\n * and ": 18011, + "Deprec": 18012, + "()).": 18013, + "projects": 18014, + "ing\\n * by making the `nonReentrant` function external, and ": 18015, + "subscriber": 18016, + "712]": 18017, + "including ": 18018, + "\"contracts/interfaces/": 18019, + "_DURATION": 18020, + "/// @inheritdoc ": 18021, + "OUT": 18022, + "leaf` ": 18023, + ") == from": 18024, + "pauseWindow": 18025, + " - 1) / b": 18026, + ").\\n *\\n * Counterpart to Solidity's `uint": 18027, + ".\\n */\\n modifier nonReentrant(": 18028, + "\\n * function is not supported. It is possible to prevent this from happen": 18029, + "s. To ": 18030, + "ExitPool": 18031, + "helps ": 18032, + "srcRepOld": 18033, + "ing the\\n * zero ": 18034, + "contains(set, value": 18035, + "filteredCodeHash": 18036, + "Ente": 18037, + "[EIP 712]": 18038, + " bits\\\");\\n return uint": 18039, + ".\\n * Only ": 18040, + "_lock('": 18041, + "](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified": 18042, + "[EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified": 18043, + ") {\\n require(value <= type(uint": 18044, + "increases ": 18045, + ", so we round ": 18046, + "Set storage set, bytes32 value) private returns (bool) {\\n ": 18047, + "Elements are ": 18048, + "safeTransferFrom(from, to, tokenId, \\\"\\\"": 18049, + " from uint256, reverting on\\n * overflow (when the input is greater than largest uint": 18050, + "er's Delight": 18051, + "Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom}\\n * ": 18052, + ").interfaceId ||\\n interfaceId == type(IERC721Metadata": 18053, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _transferOwnership(_msgSender());\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev ": 18054, + "tree up": 18055, + "try IERC721Receiver(to).onERC721Received(_msgSender(), ": 18056, + "_status = _ENTERED": 18057, + "rebuilt ": 18058, + "tree. ": 18059, + ") internal pure virtual returns (": 18060, + "pre-images are ": 18061, + "unchecked {\\n return _currentIndex - ": 18062, + "e-2.0": 18063, + "set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev ": 18064, + "If `to` refers to a smart contract, it must implement\\n * {IERC721Receiver-onERC721Received}, which is called upon a safe transfer": 18065, + "0.7.6": 18066, + "{\\n // This is equivalent to `delete _tokenApprovals[tokenId]`.\\n sstore(approvedAddressSlot, 0)\\n }\\n }\\n\\n // Underflow of the sender's balance is impossible because we check for\\n // ownership above and the recipient's balance can't realistically overflow.\\n // Counter overflow is incredibly unrealistic as ": 18067, + "activat": 18068, + "signing domain": 18069, + "assumed to be sorted": 18070, + "(_IMPLEMENTATION_SLOT).": 18071, + "Apache-2.0": 18072, + ").interfaceId ||\\n super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner": 18073, + "root of the tree. ": 18074, + " is Context, ERC165, IERC721": 18075, + "+= quantity`.\\n // - `numberMinted += quantity`.\\n //\\n // We can directly add to the `balance` and `numberMinted": 18076, + "\\\"Hacker's Delight": 18077, + "Filtered": 18078, + ")\\n );\\n\\n // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .\\n if (prevOwnershipPacked ": 18079, + " == 0) {\\n uint256 nextTokenId = tokenId + 1;\\n // If the next slot's address is zero and not burned (i.e. packed value is zero).\\n if (_packedOwnerships[nextTokenId] == 0) {\\n // If the next slot is within bounds.\\n if (nextTokenId != _currentIndex) {\\n // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.\\n _packedOwnerships[nextTokenId] = prevOwnershipPacked;\\n }\\n }\\n }\\n }\\n\\n emit Transfer": 18080, + "Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`": 18081, + "Equivalent to `safeTransferFrom(from, to, tokenId, '')`.\\n */\\n function ": 18082, + ");\\n\\n // Clear approvals from the previous owner.\\n assembly {\\n if approvedAddress {\\n // This is equivalent to `delete _tokenApprovals[tokenId]`.\\n sstore(approvedAddressSlot, 0)\\n }\\n }\\n\\n // Underflow of the sender's balance is impossible because we check for\\n // ownership above and the recipient's balance can't realistically overflow.\\n // Counter overflow is incredibly unrealistic as ": 18083, + "private` function that does the actual work.\\n */\\n modifier nonReentrant(": 18084, + "By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200": 18085, + "Icsa": 18086, + "call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant(": 18087, + "\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and ": 18088, + "pre-images are assumed to be sorted": 18089, + "Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and ": 18090, + " OR ": 18091, + "*\\n * ": 18092, + "1 << ": 18093, + "9c": 18094, + "daily": 18095, + "js.": 18096, + "nested": 18097, + "{\\n * ": 18098, + "\\n ": 18099, + "s an address ": 18100, + "ense ": 18101, + "int32": 18102, + ", scalingFactor": 18103, + "unit": 18104, + "function.\\n *\\n * ": 18105, + "ower ": 18106, + ");\\n * ": 18107, + ": the ": 18108, + ": amount exceeds ": 18109, + "an the ": 18110, + "contractBalance ": 18111, + "prior ": 18112, + "by subtrac": 18113, + "partition": 18114, + "the zero address\\\");\\r\\n require(": 18115, + "errorCode": 18116, + "currentAmp": 18117, + " ___": 18118, + "this one": 18119, + "bytes32 internal ": 18120, + "Inter": 18121, + ") internal pure returns (uint256) {\\r\\n ": 18122, + "in the contract": 18123, + "payable(": 18124, + "End ": 18125, + "Note ": 18126, + "meant": 18127, + ",\\n address to,\\n uint256 deadline": 18128, + "updateSellFees": 18129, + "output ": 18130, + ".\\n *\\n * This ": 18131, + ".\\n _totalSupply -= ": 18132, + ".\\n error ": 18133, + ".\\n *\\n * ": 18134, + "To prevent ": 18135, + "s\\n * zero.\\n */\\n function average": 18136, + "_setTokenRoyalty": 18137, + "first read ": 18138, + "priceAverage": 18139, + "caller is not token ": 18140, + "}\\r\\n ": 18141, + "string memory) {\\n return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH": 18142, + "initialize ": 18143, + "s `amount` tokens from the caller": 18144, + "_Available since v4.5._": 18145, + "status = _": 18146, + "TokenId = _": 18147, + "_PRO": 18148, + "venance ": 18149, + "track of ": 18150, + "_status != ": 18151, + "), \\\"ERC721: transfer to non ERC721Receiver implementer": 18152, + "`).\\n */\\n function _": 18153, + "replace the ": 18154, + ",\\n bytes memory _data\\n ) internal virtual {\\n _mint": 18155, + "shl(_": 18156, + "ERC20-allowance": 18157, + "portion": 18158, + "Initializer": 18159, + "token/ERC721/IERC721.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../": 18160, + "\\\";\\n uint8 private constant _ADDRESS_LENGTH = 20": 18161, + "uint256(_at(set._inner, index": 18162, + "earlyBuy": 18163, + "bigg": 18164, + "ridge": 18165, + "constructor() ERC20(\\\"": 18166, + "proxy/utils/": 18167, + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow": 18168, + "#######(": 18169, + "_msgSender() == owner || ": 18170, + "retrieve ": 18171, + ";\\n\\n // Mapping from token ID to approved address\\n mapping(uint256 => address) private ": 18172, + "`.\\n uint256 private constant _": 18173, + "0 ? string(abi.encodePacked(baseURI, tokenId.toString())": 18174, + "` to the lower 160 bits, in case the upper bits somehow aren't clean.\\n owner := and": 18175, + ".\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, `tokenId` will be burned by `from`.\\n * - `from` and `to` are never both zero.\\n */\\n function _": 18176, + "rounds up ": 18177, + "Request memory ": 18178, + "Immutable": 18179, + "index out of bounds\\\");\\n return ": 18180, + "path[1] = ": 18181, + "SeaDrop(seaDropImpl": 18182, + "(\\n address from,\\n address to,\\n uint256 amount\\n ) external returns (bool);\\n}\\n\"": 18183, + "feeRate.": 18184, + "approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20": 18185, + "put in plac": 18186, + "decrementing then incrementing": 18187, + "two numbers. The result is rounded towards\\n * zero.\\n */\\n function average": 18188, + "(address addr) internal pure returns (string memory) {\\n return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH": 18189, + "BITPOS_NUMBER_MINTED) | 1);\\n\\n // Updates:\\n // - `address` to the owner.\\n // - `startTimestamp` to the timestamp of minting.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `quantity == 1`.\\n _packedOwnerships[startTokenId": 18190, + "ownership.burned == false": 18191, + "Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.\\n owner := and": 18192, + "_status != _ENTERED": 18193, + "0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ": 18194, + "two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow": 18195, + "\"l": 18196, + "(a ": 18197, + "(bool _": 18198, + "). We ": 18199, + "1 and ": 18200, + "3C": 18201, + "6 ": 18202, + "Kind ": 18203, + "Rang": 18204, + "S\\n // =============================================================": 18205, + "_call": 18206, + "`.\\n *\\n * Requirements:\\n *\\n * - `": 18207, + "bank": 18208, + "duc": 18209, + "gaug": 18210, + "s,\\n ": 18211, + "\\n@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@": 18212, + "\\n _status = _ENTERED": 18213, + "adv": 18214, + "invalid": 18215, + "inclusive": 18216, + "unlik": 18217, + "ed the ": 18218, + "amount is ": 18219, + "` - the first ": 18220, + "fromTokenId": 18221, + "accu": 18222, + "else {": 18223, + "es a ": 18224, + "(address _address": 18225, + "(uint256 tokenAmount": 18226, + "token owner": 18227, + "e {\\n ": 18228, + "\\n // decrementing then incrementing": 18229, + "Requirements:\\n *\\n * ": 18230, + "\\n }\\n\\n ": 18231, + "contents ": 18232, + "s[msg.sender": 18233, + "] = _balances[recipient": 18234, + "Unlock": 18235, + ")))\\n ": 18236, + "Project ": 18237, + ".\\n * This ": 18238, + "path[0] = ": 18239, + "points to ": 18240, + "fees are ": 18241, + "latest ": 18242, + ")\\n _status = _NOT_ENTERED": 18243, + "_SEND": 18244, + ",\\n '": 18245, + " /**\\n * ": 18246, + "}.\\n */\\n function ": 18247, + "ech/": 18248, + ")\\\", p0, p1));\\n\\t}\\n\\n\\tfunction ": 18249, + "updateBuyFees": 18250, + "Delegat": 18251, + ".\\n _balances[account] += amount": 18252, + ".\\n ": 18253, + "startTokenId` - the first ": 18254, + "owner query for nonexistent token": 18255, + "packed >> _": 18256, + "PERIO": 18257, + "ixel": 18258, + ") public view returns (bool": 18259, + "because there is ": 18260, + "fyToken": 18261, + "position of the ": 18262, + "encoding\\n * ": 18263, + ".sol\\\";\\nimport \\\"../../utils/Address": 18264, + "largest of two numbers.\\n */\\n function ": 18265, + "UNSAFE_": 18266, + "see {_totalMinted": 18267, + "smaller ": 18268, + "_allTokensIndex[tokenId": 18269, + ")\\n public\\n ": 18270, + "AGPL-3.0": 18271, + "Seconds.add(": 18272, + "TOKEN C": 18273, + "unchecked {\\n // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above": 18274, + ".\\n *\\n * NOTE: This ": 18275, + "totalSupply = ": 18276, + "DAO": 18277, + "s from standard ": 18278, + ")\\\", p0, p1, p2));\\n\\t}\\n\\n\\tfunction log(address ": 18279, + "marketplaces ": 18280, + "more expensive": 18281, + ")\\n external\\n onlyOwner": 18282, + "enforce ": 18283, + "& _BITMASK_NEXT_INITIALIZED": 18284, + "merkle tre": 18285, + "Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified": 18286, + "al representation.\\n */\\n function toHexString(address addr) internal pure returns (string memory) {\\n return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH": 18287, + "`\\n * - `extraData = ": 18288, + "toMasked ": 18289, + "toMasked, ": 18290, + "buybackFeeReceiver": 18291, + ")\\\", p0, p1, p2));\\n\\t}\\n\\n\\tfunction log(bool ": 18292, + ")\\\", p0, p1, p2));\\n\\t}\\n\\n\\tfunction log(string memory ": 18293, + "burnFrom(address account, uint256 amount": 18294, + "capped to a ": 18295, + "history ": 18296, + ") { return ": 18297, + "Emit the `Transfer` ": 18298, + "<< _BITPOS_EXTRA_DATA": 18299, + "a set of serially-ordered token ID": 18300, + ";\\n uint256 private constant _ENTERED = 2": 18301, + "TokenApprovalRef ": 18302, + "address(0) && ownership.burned == false": 18303, + "allowed SeaDrop contract": 18304, + "@notice ": 18305, + "Underlying": 18306, + ".\\n unchecked {\\n // Updates:\\n // - `balance += quantity`.\\n // - `numberMinted += quantity`.\\n //\\n // We can directly add to the `balance` and `numberMinted": 18307, + "`quantity` - the amount to be transferred": 18308, + "] = _packOwnershipData(\\n to,\\n _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, ": 18309, + "(i.e. `ownership.addr": 18310, + "getApprovedSlotAndAddress(tokenId": 18311, + "attribut": 18312, + "_approve(address(this), address(uniswapV2Router), ": 18313, + "UniswapV3Pool": 18314, + "therwis": 18315, + "restricted ": 18316, + ")\\\", p0, p1, p2));\\n\\t\\tignored;\\n\\t}\\n\\n\\tfunction log(": 18317, + "lastManualLpBurnTime": 18318, + "b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a ": 18319, + "StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).": 18320, + " DATA ": 18321, + "AMMPair": 18322, + ");\\n }\\n\\n /**\\n * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecim": 18323, + "the sum of all balances is capped by totalSupply, and the sum is preserved by\\n // decrementing then incrementing": 18324, + "N_COINS": 18325, + "NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2": 18326, + "(\\n address owner,\\n address spender,\\n uint256 amount\\n ) internal virtual {\\n uint256 currentAllowance = allowance(owner, spender);\\n if (currentAllowance != type(uint256).max) {\\n require(currentAllowance >= amount, \\\"ERC20: insufficient allowance\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - amount);\\n }\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {}\\n\\n /**\\n * @dev Hook that is called after any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * has been transferred to `to`.\\n * - when `from` is zero, `amount` tokens have been minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {}\\n}\\n\"": 18327, + "recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20": 18328, + "isApprovedForAll(from, _msgSenderERC721A())) revert TransferCallerNotOwnerNorApproved": 18329, + "Any calls to nonReentrant after this point will fail\\n _status = _ENTERED": 18330, + "By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200)\\n _status = _NOT_ENTERED": 18331, + ".\\n _totalSupply -= amount;\\n }\\n\\n emit Transfer": 18332, + ";\\n\\n // Mapping from token ID to approved address\\n mapping(uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping(address => mapping(address => bool)) private _operatorApprovals": 18333, + ".\\n _balances[account] += amount;\\n }\\n ": 18334, + "startTokenId` - the first token ID": 18335, + "PERIOD": 18336, + "largest of two numbers.\\n */\\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a ": 18337, + "Seconds.add(days": 18338, + "TOKEN COUNT": 18339, + "unchecked {\\n // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\\n _balances[account] += amount;\\n }\\n ": 18340, + "Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)\\n * ": 18341, + "Emit the `Transfer` event": 18342, + "address(0) && ownership.burned == false`)": 18343, + "] = _packOwnershipData(\\n to,\\n _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)\\n ": 18344, + ");\\n }\\n\\n /**\\n * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\\n */\\n function toHexString(address addr) internal pure returns (string memory) {\\n return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH": 18345, + "the sum of all balances is capped by totalSupply, and the sum is preserved by\\n // decrementing then incrementing.\\n ": 18346, + "!_exists(tokenId), \\\"ERC721: ": 18347, + "\"X": 18348, + "\"0\"": 18349, + "(uint256": 18350, + ".pop(": 18351, + "/256 bits": 18352, + "CVX": 18353, + "Frozen": 18354, + "Ist": 18355, + "Tier": 18356, + "_out": 18357, + "_extraData": 18358, + "`token": 18359, + "a6": 18360, + "native": 18361, + "resc": 18362, + "roy ": 18363, + "amount. Since ": 18364, + "matron": 18365, + "accounts with ": 18366, + "transfers": 18367, + "ERC20Capped": 18368, + "return the current ": 18369, + "buf": 18370, + "diver": 18371, + "provider": 18372, + "bytes32[] memory": 18373, + "value of a ": 18374, + "value makes ": 18375, + "that does not ": 18376, + "low in ": 18377, + "the\\n * ": 18378, + "0x4": 18379, + "0xa": 18380, + "0xd": 18381, + " * x": 18382, + "/// @param _": 18383, + "of the full ": 18384, + "s[role].": 18385, + "coming into ": 18386, + "; // S": 18387, + "e the refund ": 18388, + "file": 18389, + "will be lower ": 18390, + "OpenZeppelin Contracts v4.": 18391, + "OpenZeppelin Contracts (last updated v4.": 18392, + "exceeds the ": 18393, + "RewardPool": 18394, + "Restr": 18395, + "after-": 18396, + "block.timestamp <= ": 18397, + "s are capped to a ": 18398, + ";\\n }\\n\\n /**\\n * @dev See {IERC721Enumerable-": 18399, + "burned.": 18400, + "EXP": 18401, + "EnumerableMap": 18402, + ";\\r\\n }\\r\\n }\\r\\n": 18403, + "\\n *\\n * @param _": 18404, + "they have ": 18405, + "token IDs owned by ": 18406, + "_buyback": 18407, + "- `index` must be strictly less than {length": 18408, + "gas, it is ": 18409, + "result += 1": 18410, + "like this one": 18411, + "Shif": 18412, + ") >> 1": 18413, + "amount exceeds allowance\\\")": 18414, + "External ": 18415, + "Shares ": 18416, + "how much ": 18417, + "them low in ": 18418, + "JoinPool": 18419, + "exemptFee": 18420, + "() external view returns (address);\\n\\n function ": 18421, + "MerkleProof.": 18422, + "ile: ": 18423, + "non-zero value makes ": 18424, + "{\\n using Address for address;\\n using Strings for uint256": 18425, + "NFT Royalty ": 18426, + " a bit ": 18427, + "to != owner": 18428, + "_addressData[to].": 18429, + "smart contract ": 18430, + "exchange the refund ": 18431, + "refunds are capped to a ": 18432, + "ffffffffffffffffffffffffffffffffffffffffffffffffffffffff": 18433, + "blog.openzeppelin.com/": 18434, + "disabled.": 18435, + " \\u003c ": 18436, + "deployment a bit ": 18437, + ";\\n // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\\n // decrementing then incrementing.\\n ": 18438, + "Allocation": 18439, + " of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+": 18440, + "(\\n IERC20 token,\\n address spender,\\n uint256 value\\n ) internal {\\n ": 18441, + "revert(add(32, reason), mload(reason))": 18442, + "_startTokenId()`.": 18443, + "`spender` is allowed to ": 18444, + "roleMembers[role].": 18445, + "checkpoints[account][": 18446, + "copies ": 18447, + "increase the likelihood ": 18448, + "address[] memory path = new address[](": 18449, + "divide by ": 18450, + "best to keep ": 18451, + ",\\n uint amountAMin,\\n uint amountBMin,\\n address to,\\n uint deadline": 18452, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _transferOwnership(_msgSender());\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\"": 18453, + ");\\n\\n // Clear approvals from the previous owner.\\n assembly {\\n if approvedAddress {\\n // This is equivalent to `delete _tokenApprovals[tokenId]`.\\n sstore(approvedAddressSlot, 0)\\n }\\n }\\n\\n // Underflow of the sender's balance is impossible because we check for\\n // ownership above and the recipient's balance can't realistically overflow.\\n // Counter overflow is incredibly unrealistic as `tokenId` would have to be 2**256": 18454, + ".\\n *\\n * Requirements:\\n *\\n * ": 18455, + "accurac": 18456, + " /**\\n * @dev Returns the ": 18457, + "merkle trees ": 18458, + "!_exists(tokenId), \\\"ERC721: token already minted": 18459, + "Istanbul": 18460, + "amount. Since refunds are capped to a ": 18461, + "of the full refund ": 18462, + "- `index` must be strictly less than {length}.\\n */\\n function ": 18463, + "gas, it is best to keep ": 18464, + "non-zero value makes deployment a bit ": 18465, + "NFT Royalty Standard": 18466, + "exchange the refund on every ": 18467, + ";\\n // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\\n // decrementing then incrementing.\\n _balances[to] += ": 18468, + "increase the likelihood of the full refund ": 18469, + ".\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function ": 18470, + "gas, it is best to keep them low in ": 18471, + " function ": 18472, + "#@": 18473, + "/` in ": 18474, + "30.": 18475, + "Sold": 18476, + "WH": 18477, + "_sellMarketingFee": 18478, + "`private": 18479, + "penalty": 18480, + "pending ": 18481, + "s.s": 18482, + "{nonReentrant": 18483, + "\\n*/": 18484, + "toTokenId": 18485, + "resol": 18486, + ", functions marked ": 18487, + ") calls to ": 18488, + "ing, and it ": 18489, + "ed around ": 18490, + "a != ": 18491, + "` `nonReentrant` ": 18492, + "such": 18493, + "ERC20.sol\\\";\\nimport \\\"../../../": 18494, + "external` `nonReentrant` ": 18495, + ") internal override ": 18496, + "and alternative ": 18497, + " to first read ": 18498, + "require(\\r\\n ": 18499, + ") external {\\n return super._": 18500, + "if (to.isContract()": 18501, + "behalf": 18502, + "contract upgrades ": 18503, + "token == ": 18504, + "this, ": 18505, + ";\\n\\n/*": 18506, + "on addition": 18507, + ").div": 18508, + ") {\\n return": 18509, + "contents, ": 18510, + "cannot be disabled.": 18511, + "MMM": 18512, + "OnSell": 18513, + "than uint256 or ": 18514, + "defense ": 18515, + "out our ": 18516, + "Load": 18517, + "any type that ": 18518, + "call one ": 18519, + "s are more expensive ": 18520, + ";\\n\\n // =============================================================\\n // ": 18521, + "back. This is the ": 18522, + "tokensForBurn": 18523, + ";\\n\\n _": 18524, + "functions `private": 18525, + "call to nonReentrant ": 18526, + "ondon\"": 18527, + "Counterpart to Solidity\\u0027s `": 18528, + "operation emits an ": 18529, + ");\\n }\\n\\n /**\\n * @dev Returns the unpacked `TokenOwnership` struct ": 18530, + "Guarant": 18531, + "each write ": 18532, + "Note that because there is ": 18533, + "up by the ": 18534, + "division with `": 18535, + ", which can be applied to ": 18536, + "staking ": 18537, + "being non-zero value makes deployment a bit ": 18538, + ".sol\\\";\\n\\nabstract contract ": 18539, + "because each write ": 18540, + "dropStage": 18541, + "ReentrancyGuard` will ": 18542, + "worked around ": 18543, + "check out our ": 18544, + "values being non-zero value makes deployment a bit ": 18545, + "producing ": 18546, + "releas": 18547, + "calculated ": 18548, + "available, which can be applied to ": 18549, + "\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function ": 18550, + "\\n // =============================================================\\n\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)\\n * ": 18551, + ") external view returns (bool);\\n\\n // =============================================================\\n // ": 18552, + "prevent reentrant ": 18553, + "overflow on addition": 18554, + ");\\n }\\n\\n if (": 18555, + "a single `nonReentrant` ": 18556, + "divisor": 18557, + "parameters ": 18558, + "means that ": 18559, + "bits taken ": 18560, + "() public view override returns (": 18561, + "Authoriz": 18562, + "tokenIndex] = ": 18563, + "ing `external` `nonReentrant` ": 18564, + "`nonReentrant` may not ": 18565, + "functions to make sure ": 18566, + ") {\\n return ": 18567, + "against contract upgrades ": 18568, + "OPERATIONS\\n // =============================================================\\n\\n /**\\n * @dev Returns the ": 18569, + "`, and then add": 18570, + "from `ReentrancyGuard` will ": 18571, + "reentrancy and alternative ": 18572, + "to learn more about reentrancy and alternative ": 18573, + "voting power": 18574, + "TIP: If you ": 18575, + "word because each write ": 18576, + "PROOF": 18577, + "/[Reentrancy ": 18578, + "ceiling of the ": 18579, + "those functions `private": 18580, + "to learn more about how these ids are created.\\n *\\n * This function call must use less than 30000 ": 18581, + "there are no nested": 18582, + "pointer alias": 18583, + ".\\n *\\n * `startTokenId` - the first token ID": 18584, + "it's recommended to use it alway": 18585, + " OPERATIONS\\n // =============================================================\\n\\n /**\\n * @dev Returns the ": 18586, + "make the {nonReentrant": 18587, + "LevelCall": 18588, + "` in packed ownership.\\n uint256 private constant _": 18589, + "protect against it, ": 18590, + "BasicToken": 18591, + "Booleans are more expensive ": 18592, + "artistAddress": 18593, + "blog post": 18594, + "(address to, uint256 quantity) internal virtual {\\n uint256 ": 18595, + "another. This can be ": 18596, + ") internal pure returns (address, RecoverError) {\\n // ": 18597, + "cases like this one": 18598, + "Time = block.timestamp": 18599, + "1, 2, ": 18600, + "}\\n }\\n\\n // =============================================================\\n // ": 18601, + "After Istanbul": 18602, + "// File: ": 18603, + ", and then write": 18604, + "SenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A())": 18605, + "Contract module that helps ": 18606, + " of the `nextInitialized` bit in packed ownership.\\n uint256 private constant _": 18607, + "takes up a ": 18608, + "}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom": 18609, + "IDexRouter": 18610, + ") {\\n assembly {\\n // Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.\\n owner := and": 18611, + "guard, functions marked ": 18612, + "a ^ b) / 2": 18613, + " to be transferred.\\n * `quantity` - the amount to be transferred": 18614, + "istanbul/[Reentrancy ": 18615, + "if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A())": 18616, + "c >= a, \\\"SafeMath: addition overflow": 18617, + "percentage of the total": 18618, + "reentrancy-after-": 18619, + "}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function ": 18620, + " can overflow on addition": 18621, + "from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function ": 18622, + "a & b) + (a ^ b) / 2": 18623, + "reentrant) calls to ": 18624, + "proportional to the ": 18625, + "TopLevelCall": 18626, + "[to] += quantity * ((1 << _": 18627, + "class of bugs, so it's recommended to use it alway": 18628, + "differs from standard ": 18629, + " IERC721Metadata\\n // =============================================================\\n\\n /**\\n * @dev Returns the ": 18630, + " IERC165\\n // =============================================================\\n\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)\\n * ": 18631, + "boolean, and then write": 18632, + "extra SLOAD to first read ": 18633, + "but in exchange the refund on every ": 18634, + "would like to learn more about reentrancy and alternative ": 18635, + "Inheriting from `ReentrancyGuard` will ": 18636, + "(uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId": 18637, + "total number of tokens in existence.\\n * Burned tokens will reduce the count.\\n * To get the total number of tokens minted, please see {_totalMinted": 18638, + " - 1) / b can overflow on addition": 18639, + "If `to` refers to a smart contract, it must implement\\n * {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function ": 18640, + "replace the bits taken ": 18641, + "`.\\n uint256 private constant _BITMASK": 18642, + "\"london\"": 18643, + "Seconds.add(days30.": 18644, + "coming into effect": 18645, + "blog.openzeppelin.com/reentrancy-after-": 18646, + "amount. Since refunds are capped to a percentage of the total": 18647, + ";\\n // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\\n // decrementing then incrementing.\\n _balances[to] += amount;\\n }\\n\\n emit Transfer": 18648, + "increase the likelihood of the full refund coming into effect": 18649, + "gas, it is best to keep them low in cases like this one": 18650, + "/` in that it ": 18651, + "ing, and it cannot be disabled.": 18652, + "contents, replace the bits taken ": 18653, + "than uint256 or any type that ": 18654, + "defense against contract upgrades ": 18655, + "call one another. This can be ": 18656, + "call to nonReentrant will be lower ": 18657, + "operation emits an extra SLOAD to first read ": 18658, + "Note that because there is a single `nonReentrant` ": 18659, + "up by the boolean, and then write": 18660, + "division with `/` in that it ": 18661, + "worked around by mak": 18662, + "check out our blog post": 18663, + "values being non-zero value makes deployment a bit more expensive": 18664, + "available, which can be applied to functions to make sure ": 18665, + "prevent reentrant calls to a ": 18666, + "ing `external` `nonReentrant` entry": 18667, + "`nonReentrant` may not call one another. This can be ": 18668, + "`, and then adding `external` `nonReentrant` entry": 18669, + "TIP: If you would like to learn more about reentrancy and alternative ": 18670, + "word because each write operation emits an extra SLOAD to first read ": 18671, + "ceiling of the division of ": 18672, + "those functions `private`, and then adding `external` `nonReentrant` entry": 18673, + "pointer aliasing, and it cannot be disabled.": 18674, + ".\\n *\\n * `startTokenId` - the first token ID to be transferred.\\n * `quantity` - the amount to be transferred": 18675, + "make the {nonReentrant} ": 18676, + "protect against it, check out our blog post": 18677, + "Booleans are more expensive than uint256 or any type that ": 18678, + "After Istanbul].": 18679, + "Contract module that helps prevent reentrant calls to a ": 18680, + "takes up a full": 18681, + "istanbul/[Reentrancy After Istanbul].": 18682, + "differs from standard division with `/` in that it ": 18683, + " IERC165\\n // =============================================================\\n\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30000 ": 18684, + "but in exchange the refund on every call to nonReentrant will be lower ": 18685, + "Inheriting from `ReentrancyGuard` will make the {nonReentrant} ": 18686, + " - 1) / b can overflow on addition, so we distribute": 18687, + "blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].": 18688, + "gas, it is best to keep them low in cases like this one, to": 18689, + "contents, replace the bits taken up by the boolean, and then write": 18690, + "Note that because there is a single `nonReentrant` guard, functions marked ": 18691, + "available, which can be applied to functions to make sure there are no nested": 18692, + "`nonReentrant` may not call one another. This can be worked around by mak": 18693, + "TIP: If you would like to learn more about reentrancy and alternative ways": 18694, + "Booleans are more expensive than uint256 or any type that takes up a full": 18695, + "(when the ": 18696, + ",\\n /// ": 18697, + ",\\n * ": 18698, + "600": 18699, + ";\\n *\\n * ": 18700, + "Alp": 18701, + "DR": 18702, + "[recipient": 18703, + "dg": 18704, + "sd": 18705, + "═╝": 18706, + "tur": 18707, + ", address(0)": 18708, + "returned": 18709, + "\\n * to ": 18710, + "ates the ": 18711, + "ission": 18712, + "address - ": 18713, + "` hook": 18714, + "/**\\n * @title ": 18715, + "@dev ": 18716, + "\\n * ": 18717, + "ERC20.sol\"": 18718, + "ulk": 18719, + "value\\n ) internal {\\n ": 18720, + "\\n * points to ": 18721, + "not paused": 18722, + "/ / ": 18723, + "Exec": 18724, + "numerator": 18725, + "on its ": 18726, + ", \\\"ReentrancyGuard: reentrant call": 18727, + "0xc": 18728, + ";\\n }\\n\\n /**\\n * @dev Returns true if the ": 18729, + ";\\n }\\n\\n /**\\n * @dev Sets the ": 18730, + ";\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and ": 18731, + "mul(x, y": 18732, + ") external view returns (address pair": 18733, + "\\n // transaction": 18734, + "\\n // back. This is the ": 18735, + "\\n // increase the likelihood of the full refund coming into effect": 18736, + "\\n // word because each write operation emits an extra SLOAD to first read ": 18737, + "Hash, ": 18738, + ") external;\\n}\\n\\n": 18739, + "keccak256(0x": 18740, + "pool-utils/": 18741, + "(address indexed sender": 18742, + "rewardPerToken": 18743, + ";\\n }\\n _totalSupply -= amount;\\n\\n emit Transfer": 18744, + "owner address": 18745, + "amountETHLiquidity": 18746, + " := or(": 18747, + "call to `to": 18748, + "approved address ": 18749, + "223": 18750, + "\\\"\\n );\\n require(\\n ": 18751, + "upgradeable ": 18752, + "Financ": 18753, + "overriden ": 18754, + "\\n\\t * @param ": 18755, + ".\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2": 18756, + "means the ": 18757, + "s in a ": 18758, + "restrictions on ": 18759, + "deducting ": 18760, + "destroy ": 18761, + "\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].": 18762, + ";\\n\\n uint256 private _status": 18763, + ") external;\\n\\n /**\\n * @notice Update ": 18764, + "modifier\\n * available, which can be applied to functions to make sure there are no nested": 18765, + "#(#(": 18766, + "\\n * to protect against it, check out our blog post": 18767, + "ing\\n * those functions `private`, and then adding `external` `nonReentrant` entry": 18768, + ";\\r\\n }\\r\\n\\r\\n /**\\r\\n * @dev See {IERC20-": 18769, + "Initialize": 18770, + "{\\n // Booleans are more expensive than uint256 or any type that takes up a full": 18771, + "))\\n }\\n }\\n\\n /**\\n * @dev Returns the ": 18772, + "_balances[recipient] = _balances[recipient": 18773, + ");\\n }\\n}\"": 18774, + "_RECE": 18775, + "\\n * bytes4(keccak256('": 18776, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom": 18777, + "====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size": 18778, + "free memory pointer ": 18779, + "\\n * (reentrant) calls to ": 18780, + ";\\n // Overflow not possible: amount <= accountBalance <= totalSupply": 18781, + "together with {": 18782, + "them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked ": 18783, + "them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways": 18784, + "updateSwapTokensAtAmount": 18785, + "========== */": 18786, + "\\n\\n // The values being non-zero value makes deployment a bit more expensive": 18787, + "(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes": 18788, + ",\\n // but in exchange the refund on every call to nonReentrant will be lower ": 18789, + "& _BITMASK_ADDRESS_DATA_ENTRY;\\n }\\n\\n /**\\n * Returns the number of tokens ": 18790, + "Deploy": 18791, + ") returns (bool) {\\n return\\n interfaceId == type(IERC721": 18792, + "Proposal": 18793, + ";\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0": 18794, + "Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0": 18795, + "Extension of {ERC20": 18796, + "as\\n * `nonReentrant` may not call one another. This can be worked around by mak": 18797, + "< b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow": 18798, + "affiliate": 18799, + "in\\n // amount. Since refunds are capped to a percentage of the total": 18800, + "s with added overflow\\n * ": 18801, + "floor": 18802, + "EnumerableSet for EnumerableSet.AddressSet": 18803, + ".swapExactTokensFor": 18804, + "and\\n // pointer aliasing, and it cannot be disabled.": 18805, + "Moves tokens ": 18806, + "function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} ": 18807, + "token/ERC721/IERC721.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to": 18808, + "rounds up instead": 18809, + "b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow": 18810, + "accuracy": 18811, + "!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n ": 18812, + "}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account": 18813, + "defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.": 18814, + "Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} ": 18815, + "differs from standard division with `/` in that it rounds up instead": 18816, + "gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect": 18817, + "contents, replace the bits taken up by the boolean, and then write\\n // back. This is the ": 18818, + "\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways": 18819, + "\\n // word because each write operation emits an extra SLOAD to first read the\\n // ": 18820, + ".\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status": 18821, + "modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to ": 18822, + "\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].": 18823, + "ing\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways": 18824, + "{\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // ": 18825, + "them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by mak": 18826, + "\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower ": 18827, + "in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction": 18828, + "defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower ": 18829, + "Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to ": 18830, + "gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status": 18831, + "ing\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].": 18832, + "them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].": 18833, + "defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction": 18834, + "Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].": 18835, + " signature ": 18836, + "\"Invalid ": 18837, + "\"ERC777": 18838, + "(https://github.com/": 18839, + "(fees * ": 18840, + ".\\n * @param _": 18841, + "/lib/": 18842, + "JEC": 18843, + "PY": 18844, + "Writ": 18845, + "];\\n\\n emit Transfer": 18846, + "_allowance": 18847, + "_BITMASK_ADDRESS": 18848, + "_exists(": 18849, + "`a": 18850, + "`uint256": 18851, + "found": 18852, + "ye": 18853, + "resh": 18854, + "ended": 18855, + "is true, the ": 18856, + "ing an ": 18857, + ": it ": 18858, + "value;\\n }\\n\\n /**\\n * @dev ": 18859, + "tokenIds.length": 18860, + "(address new": 18861, + "index = ": 18862, + "at this ": 18863, + "\\r\\n\\r\\n function ": 18864, + "minted by ": 18865, + "that was ": 18866, + "token collection": 18867, + "checks.\\n *\\n * ": 18868, + ");\\n\\n return ": 18869, + "signed": 18870, + "canMint": 18871, + "when filtered ": 18872, + "ContractAddress": 18873, + "\"// SPDX-License-Identifier: AGPL-3.0": 18874, + "\\r\\n * @param ": 18875, + "ProvenanceHash": 18876, + "new implementation": 18877, + "feeGrowth": 18878, + "eip1967": 18879, + "`tokenId` is ": 18880, + "pair, bool ": 18881, + "gradually ": 18882, + "_toString": 18883, + ");\\n }\\n\\n function get": 18884, + "has be": 18885, + "More ": 18886, + "safeTransferFrom(address from, address to, uint256 tokenId": 18887, + "uint256 private constant ": 18888, + "s for self": 18889, + ") internal view virtual returns (TokenOwnership memory) {\\n return _unpackedOwnership": 18890, + " > 0, \\\"": 18891, + "mechanisms to ": 18892, + "factory() external pure returns (address": 18893, + "tokenId := add(": 18894, + "e.g.\\n * ": 18895, + "ed = true": 18896, + "s.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire": 18897, + "_ The ": 18898, + "_safeMint(to, tokenId": 18899, + "reason.length": 18900, + "(x * ": 18901, + "` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add": 18902, + "\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.": 18903, + ");\\n }\\n\\n /**\\n * @dev See {IERC20Permit-": 18904, + "known": 18905, + "General": 18906, + "INITIAL_SUPPLY": 18907, + "(address spender, uint256 tokenId": 18908, + "saving": 18909, + "swap fee ": 18910, + "),\\n ": 18911, + "invariant ": 18912, + ":\\n * ": 18913, + "(owner, _BITMASK_ADDRESS)\\n // ": 18914, + "cached": 18915, + ";\\n emit Approval(": 18916, + "Track": 18917, + ", 0x20)\\n // ": 18918, + "Compli": 18919, + "Compound": 18920, + "::::::::::::::::": 18921, + "registered address - ": 18922, + "CRV": 18923, + "s[i] = ": 18924, + "isApprovedForAll(owner, spender": 18925, + "kkkk": 18926, + "exchange.": 18927, + "a given address or its subscription": 18928, + "Abstr": 18929, + "sload(": 18930, + "Airdrop": 18931, + "Map storage map": 18932, + "Maximum ": 18933, + "(from, to, amount);\\n\\n _afterTokenTransfer(from, to, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n unchecked {\\n // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\\n _balances[account] += amount;\\n }\\n ": 18934, + ".\\n mstore(str": 18935, + "onlyAllowedOperator(from) {\\n ": 18936, + "opposed to ": 18937, + "(gas(), ": 18938, + ") returns (bool) {\\n return interfaceId == type(": 18939, + "operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire": 18940, + "\\n }\\n packed = (packed & _BITMASK": 18941, + "analysis": 18942, + "1inch": 18943, + ")\\n );\\n\\n // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .\\n if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED": 18944, + ": amount exceeds 96": 18945, + "status = _NOT_ENTERED": 18946, + ".\\n unchecked {\\n // Updates:\\n // - `balance += quantity`.\\n // - `numberMinted += quantity`.\\n //\\n // We can directly add to the `balance` and `numberMinted`.\\n _packedAddressData": 18947, + ";\\n // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\\n // decrementing then incrementing.\\n _balances[to] += amount;\\n }\\n\\n emit Transfer(from, to, amount);\\n\\n _afterTokenTransfer(from, to, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n unchecked {\\n // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\\n _balances[account] += amount;\\n }\\n ": 18948, + ";\\n // Overflow not possible: amount <= accountBalance <= totalSupply.\\n _totalSupply -= amount;\\n }\\n\\n emit Transfer": 18949, + "s with added overflow\\n * checks.\\n *\\n * ": 18950, + "Moves tokens `amount` ": 18951, + "when filtered is true, the ": 18952, + "eip1967.proxy.": 18953, + "registered address - when filtered is true, the ": 18954, + "a given address or its subscription.\\n */\\n function ": 18955, + "operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * ": 18956, + "53": 18957, + "Ari": 18958, + "IE": 18959, + "Por": 18960, + "So": 18961, + "TYP": 18962, + "WL": 18963, + "_shares": 18964, + "`\\n *\\n * ": 18965, + "c < ": 18966, + "mix": 18967, + "native ": 18968, + "site": 18969, + "vg": 18970, + "\\n );\\n event ": 18971, + "er.": 18972, + ", J": 18973, + "ingEnabled": 18974, + ");\\n // ": 18975, + "token1 ": 18976, + "\\n //": 18977, + "= 0": 18978, + "\\n\\n /// @notice ": 18979, + "sur": 18980, + "indexes": 18981, + "\\n }\\n\\n /**\\n * @dev Returns the ": 18982, + "from `sender` to `recipient": 18983, + "THOR": 18984, + "The token ": 18985, + "The number of tokens ": 18986, + "on SeaDrop": 18987, + "TokenIds": 18988, + ")\\n }\\n ": 18989, + "_SIZ": 18990, + "fffffff": 18991, + "&&\\r\\n ": 18992, + "}\\n if (": 18993, + "(address indexed user": 18994, + ");\\r\\n }\\r\\n\\r\\n ": 18995, + "1 word ": 18996, + "WETH() external pure returns (address": 18997, + ".\\n uint256 ": 18998, + "s = new ": 18999, + "on the set. O(1": 19000, + "scaling ": 19001, + "static call failed\"": 19002, + ", 1)\\n } ": 19003, + "Mapping from ": 19004, + "while (true": 19005, + "_allTokens[": 19006, + "] = true;\\r\\n ": 19007, + "(sender, recipient, amount);\\n ": 19008, + "Application": 19009, + "Validator": 19010, + "assert(": 19011, + "\\n require(_status != _ENTERED": 19012, + "approve(address to, uint256 tokenId) internal virtual {\\n ": 19013, + "\"Address: low-level static call failed\"": 19014, + "average ": 19015, + "related to ": 19016, + "[account]": 19017, + "considered ": 19018, + "Subtract ": 19019, + "nft contract ": 19020, + "range, ": 19021, + "Spec": 19022, + "Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom": 19023, + "incredibly unrealistic": 19024, + "insufficient allowance\"": 19025, + "\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED": 19026, + "explicitOwnershipOf": 19027, + "switch": 19028, + "\\r\\n /**\\r\\n * @dev Returns the ": 19029, + "Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function ": 19030, + "emit Transfer(address(0), account, amount);\\n\\n _afterTokenTransfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n unchecked {\\n _balances[account] = accountBalance - amount;\\n // Overflow not possible: amount <= accountBalance <= totalSupply.\\n _totalSupply -= amount;\\n }\\n\\n emit Transfer": 19031, + "exactly ": 19032, + "ReentrancyGuard {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // ": 19033, + "IDEXRouter": 19034, + "powers of ": 19035, + "getApproved(tokenId) == spender": 19036, + "\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\"": 19037, + "(\\n uint256 a,\\n uint256 b,\\n string memory errorMessage\\n ": 19038, + "██╔══": 19039, + "Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function ": 19040, + "renounce role": 19041, + "frequencyInSeconds": 19042, + "Data storage ": 19043, + ") internal onlyInitializing ": 19044, + ") == from, \\\"ERC721: ": 19045, + "token IDs owned by `owner": 19046, + ") {\\n assembly {\\n // Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.\\n owner := and(owner, _BITMASK_ADDRESS)\\n // ": 19047, + ", \\\"ReentrancyGuard: reentrant call\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED": 19048, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 amount\\n ) external returns (bool);\\n}\\n\"": 19049, + ";\\n // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\\n // decrementing then incrementing.\\n _balances[to] += amount;\\n }\\n\\n emit Transfer(from, to, amount);\\n\\n _afterTokenTransfer(from, to, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n unchecked {\\n // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\\n _balances[account] += amount;\\n }\\n emit Transfer(address(0), account, amount);\\n\\n _afterTokenTransfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n unchecked {\\n _balances[account] = accountBalance - amount;\\n // Overflow not possible: amount <= accountBalance <= totalSupply.\\n _totalSupply -= amount;\\n }\\n\\n emit Transfer": 19050, + "Moves tokens `amount` from `sender` to `recipient": 19051, + "\\n require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED": 19052, + "\"/contracts/": 19053, + "(uint16 ": 19054, + "47": 19055, + " a": 19101, + "uint amountB": 19102, + "e that the ": 19103, + "tion by ": 19104, + "27e": 19105, + "delay": 19106, + "bool,address": 19107, + "bool,bool": 19108, + "bool,string": 19109, + "s for a ": 19110, + "no restrictions on ": 19111, + "implement alternative ": 19112, + "included ": 19113, + ");\\n require(_checkOnERC721Received": 19114, + "} and {ERC20-allowance": 19115, + "power ": 19116, + "If the `tokenId` is ": 19117, + "custom:": 19118, + "Metadata {\\n using Address for address;\\n using Strings for uint256": 19119, + "Internal Balance ": 19120, + "a `name` and a `": 19121, + "_msgSenderERC721A()": 19122, + ", string memory errorMessage) private pure ": 19123, + "additional data": 19124, + "operator query for nonexistent token": 19125, + ".\\n *\\n * _Available since v4.7._\\n */\\n function ": 19126, + "a contract.\\n *\\n * @param ": 19127, + "_000_000_000": 19128, + ",\\n bool approveMax, uint8 v, bytes32 r, bytes32 s": 19129, + ".\\n * The call is not executed if the target address is not ": 19130, + "address(this),\\n ": 19131, + "(\\n bytes32 poolId": 19132, + "pendingOwner": 19133, + "ProjectId": 19134, + "Returns whether `spender` is allowed to ": 19135, + "Out = ": 19136, + "Stored": 19137, + "ability for ": 19138, + "there is a ": 19139, + "xsd": 19140, + "AccessControl: can only ": 19141, + "token transfer, such as ": 19142, + "\\\",\\\"name\\\":\\\"": 19143, + ", IERC721Metadata {\\n using Address for address;\\n using Strings for uint256": 19144, + "_OVERFLOW": 19145, + "multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `": 19146, + "integer division of two unsigned integ": 19147, + "Remainder ": 19148, + "(uint16 _srcChainId": 19149, + "\\\"],\\n [\\\"": 19150, + "address signer = ecrecover": 19151, + "_balances[sender] = _balances[sender": 19152, + "].sub(amount, \\\"ERC20: transfer amount exceeds allowance\\\")": 19153, + "accounts that have `role": 19154, + "facilitator": 19155, + "Offset": 19156, + "LOGIC\\n //////////////////////////////////////////////////////////////*/\\n\\n function ": 19157, + "(uint256 x, uint256 ": 19158, + "depending on the ": 19159, + "addressData[owner].": 19160, + "(receiver, feeNumerator": 19161, + "UniswapPairOracle": 19162, + "INonFungibleSeaDropToken": 19163, + "_balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n\\n _afterTokenTransfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n unchecked {\\n _balances[account] = accountBalance - amount": 19164, + "As opposed to ": 19165, + "Art Block": 19166, + ")));\\r\\n _lock('": 19167, + "messaging ": 19168, + "by setting a `name` and a `": 19169, + "(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) public virtual override {\\n ": 19170, + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n uint256 c = a + b;\\n require(": 19171, + "Returns an array of token IDs owned by `owner": 19172, + "Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not ": 19173, + "meant to be ": 19174, + "proxy/utils/Initializable": 19175, + "BITPOS_NUMBER_MINTED) | 1);\\n\\n // Updates:\\n // - `address` to the owner.\\n // - `startTimestamp` to the timestamp of minting.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `quantity == 1`.\\n _packedOwnerships[startTokenId] = _packOwnershipData(\\n to,\\n _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)\\n ": 19176, + "(address to, uint256 quantity) internal virtual {\\n uint256 startTokenId = _currentIndex;\\n if (": 19177, + "Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ": 19178, + "Arithme": 19179, + "c < a": 19180, + "Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account": 19181, + "Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account": 19182, + "renounce roles for self": 19183, + "oses no restrictions on ": 19184, + "internalType\\\":\\\"": 19185, + "symbol` to the token collection": 19186, + "implement alternative mechanisms to ": 19187, + "Returns whether `spender` is allowed to manage ": 19188, + "AccessControl: can only renounce roles for self": 19189, + "token transfer, such as signature": 19190, + "multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*": 19191, + "by setting a `name` and a `symbol` to the token collection": 19192, + "Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param ": 19193, + "oses no restrictions on msg.sender": 19194, + "(via ": 19195, + ".\\n /// @return ": 19196, + "CID": 19197, + "SWAP": 19198, + "WW": 19199, + "[WARNING": 19200, + "_c": 19201, + "_buildDomainSeparator": 19202, + "f5": 19203, + "layer": 19204, + "table": 19205, + "adr": 19206, + "ane": 19207, + ", vestingRound": 19208, + "ouch": 19209, + "turn ": 19210, + "depos": 19211, + "\\n for {": 19212, + "arren": 19213, + "f := ": 19214, + "\\\": ": 19215, + "Token: ": 19216, + ") {}\\n\\n /**\\n * @dev ": 19217, + "Tra": 19218, + "vea": 19219, + ".\\n */\\n function ceilDiv": 19220, + "contractToken": 19221, + "Inside": 19222, + "Ampl": 19223, + "*****": 19224, + "Exchange": 19225, + "token balance ": 19226, + "token contracts ": 19227, + "can use ": 19228, + ").\\n *\\n * ": 19229, + "s[_": 19230, + "buyMarketing": 19231, + "` is additional data": 19232, + "sellMarketing": 19233, + ") private {\\r\\n ": 19234, + "must be an ": 19235, + ", and can be used to ": 19236, + "Constructor": 19237, + "gencet": 19238, + "manifold": 19239, + ");\\n }\\n\\n //": 19240, + "two signed ": 19241, + "(uint256 tokenId) public view override returns (": 19242, + "positive": 19243, + ";\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of ": 19244, + "ER_B": 19245, + "AndReturn": 19246, + "was not ": 19247, + ".\\n *\\n * This differs from standard division with `/` in that it rounds up instead": 19248, + ", it has no ": 19249, + "initialized to ": 19250, + "112x112": 19251, + "NFTs ": 19252, + "10000000": 19253, + "}, this imp": 19254, + "for (uint256 i; i < ": 19255, + "at the last ": 19256, + "Algorithm": 19257, + "(`_burn": 19258, + "{transferFrom}, this imp": 19259, + "so it ": 19260, + "BeforeSwap": 19261, + "Data {\\n ": 19262, + "_totalSupply = _totalSupply": 19263, + " FUNCTION": 19264, + "PL-2.0": 19265, + "specified format ": 19266, + "perform token transfer, such as signature": 19267, + "Decimal": 19268, + ", which is the ": 19269, + "An empty ": 19270, + "allow list ": 19271, + "two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead": 19272, + "internal function is equivalent to {safeTransferFrom}": 19273, + "▓▓▓▓▓▓▓▓": 19274, + ";\\n require(c / a == b, \\\"SafeMath: multiplication overflow": 19275, + "\\n * of rounding down": 19276, + "burned (`_burn": 19277, + "info.": 19278, + "-name-mixedcase ": 19279, + "toMasked": 19280, + "existing when they are burned (`_burn": 19281, + "complex ": 19282, + "Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the\\n * zero ": 19283, + "array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function ": 19284, + "Note that there are no guarantees on the ordering of values inside the\\n * ": 19285, + "interfaces/contracts/solidity-utils/": 19286, + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute": 19287, + "and it is sent in ": 19288, + "stop existing when they are burned (`_burn": 19289, + "projects[_projectId].": 19290, + "necessarily me": 19291, + "safety ": 19292, + "MANAG": 19293, + "DOMAIN_TYPEHASH": 19294, + ".\\n return (a & b) + (a ^ b) / 2": 19295, + "middle ": 19296, + "safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function ": 19297, + ").interfaceId ||\\n interfaceId == type(IERC721Metadata).interfaceId ||\\n super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner": 19298, + "_msgSender() == owner || isApprovedForAll(owner, _msgSender())": 19299, + "return the current value and ": 19300, + "divergencet": 19301, + "b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2": 19302, + "VARI": 19303, + "As opposed to {transferFrom}, this imp": 19304, + "implement alternative mechanisms to perform token transfer, such as signature": 19305, + ".\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute": 19306, + "` is additional data, it has no ": 19307, + ";\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead": 19308, + "PL-2.0-or-later": 19309, + "specified format and it is sent in ": 19310, + "internal function is equivalent to {safeTransferFrom}, and can be used to ": 19311, + "\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute": 19312, + "Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function ": 19313, + "divergencetech/": 19314, + "b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2;\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead": 19315, + "As opposed to {transferFrom}, this imposes no restrictions on msg.sender": 19316, + "implement alternative mechanisms to perform token transfer, such as signature-based": 19317, + "` is additional data, it has no specified format and it is sent in ": 19318, + "\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute.\\n return ": 19319, + "b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2;\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute.\\n return ": 19320, + "',\\n '": 19321, + "(i": 19322, + "(block.timestamp": 19323, + ".transfer": 19324, + ".supportsInterface(interfaceId": 19325, + ".xyz": 19326, + "Given ": 19327, + "Pend": 19328, + "Sqrt": 19329, + "_require": 19330, + "_TH": 19331, + "_admin": 19332, + "because the ": 19333, + "dst ": 19334, + "found ": 19335, + "ible": 19336, + "slippage ": 19337, + "╬╣": 19338, + "alter": 19339, + "enari": 19340, + "onERC1155": 19341, + "address) {\\n return _": 19342, + "uint256 amount": 19343, + "sire": 19344, + ");\\n } else {\\n return ": 19345, + "in un": 19346, + ". W": 19347, + "} whenever possible": 19348, + ") external {\\n ": 19349, + ") public returns (bool": 19350, + "'s gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status": 19351, + "grou": 19352, + "@param b": 19353, + "cannot be zero ": 19354, + "returns (bool)\\n {\\n return ": 19355, + "uint8 _": 19356, + "000000000000": 19357, + "].length": 19358, + "using Counters for Counters.Counter": 19359, + "beforeFallback": 19360, + "manage": 19361, + "super.safeTransferFrom": 19362, + ");\\r\\n }\\r\\n": 19363, + "(address indexed account": 19364, + "ed in {": 19365, + "Role(DEFAULT_ADMIN_ROLE": 19366, + ".\\n *\\n * @dev ": 19367, + "gas during ": 19368, + "sold ": 19369, + "We know ": 19370, + "recovery ": 19371, + "about to be transferred": 19372, + "(from, to, tokenId, data": 19373, + "does not necessarily me": 19374, + "have been transferred": 19375, + "delegate call failed\"": 19376, + "let f := ": 19377, + "amount of tokens to ": 19378, + "\\n returns (uint256": 19379, + ".sol\\\";\\n\\nimport {": 19380, + "_safeMint} whenever possible": 19381, + "- 1) / b": 19382, + "slot (": 19383, + "over time": 19384, + "mint to the zero address\\\");\\n require(": 19385, + "s with custom message ": 19386, + "getAmountOut": 19387, + "Reverts with custom message ": 19388, + "invariantRatio": 19389, + ") {\\n require(": 19390, + "multipli": 19391, + "token/ERC721/extensions/ERC721Enumerable": 19392, + "\"Address: low-level delegate call failed\"": 19393, + "cases, ": 19394, + "\"// SPDX-License-Identifier: GPL-2.0-or-later": 19395, + "converges ": 19396, + ".\\n */\\n function getRoleMember": 19397, + ");\\n return (spender": 19398, + "skip": 19399, + "OOOOOOOOOOOOOOOO": 19400, + "bptAmountOut": 19401, + "1363": 19402, + ".sol\\\";\\r\\nimport \\\"./": 19403, + "⣿⣿⣿⣿⣿⣿⣿⣿": 19404, + ", ERC165 {\\n struct ": 19405, + "1,\\n 1,\\n 1,\\n 1,\\n ": 19406, + "missions": 19407, + "Emit an ": 19408, + "dynamically ": 19409, + "slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the ": 19410, + "Enumerable extension": 19411, + "NominalMain": 19412, + "nonces(address owner) external view returns (uint256": 19413, + "PaymentSplitter: ": 19414, + "Elastic": 19415, + "Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool": 19416, + "ERC721-_safeMint": 19417, + "(address owner) internal view returns (uint256) {\\n return (_packedAddressData[owner] >> _": 19418, + "set._inner, value);\\n }\\n\\n /**\\n * @dev ": 19419, + "(account, address(0), amount);\\n\\n _afterTokenTransfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(\\n address owner,\\n address spender,\\n uint256 amount\\n ) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Updates `owner` s allowance for `spender` based on spent `amount`.\\n *\\n * Does not update the allowance amount in case of infinite allowance.\\n * Revert if not enough allowance is available.\\n *\\n * Might emit an {Approval} event.\\n */\\n function _spendAllowance": 19420, + "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\\\"": 19421, + "compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction": 19422, + "override(ERC165, IERC165) returns (bool) {\\n return\\n interfaceId == type(IERC721": 19423, + "getRoleMemberCount}, ": 19424, + "baseTokenFor": 19425, + "tmpSuccess": 19426, + ";\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub": 19427, + "`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId": 19428, + "basicTransfer": 19429, + "of data (0, since no data).\\n ": 19430, + "possibility ": 19431, + " is Context, ERC165, IERC721, IERC721Metadata {\\n using Address for address;\\n using Strings for uint256": 19432, + "`).\\n */\\n function _exists(uint256 tokenId": 19433, + "burnFrom(address account, uint256 amount) public virtual ": 19434, + " of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add": 19435, + "Guaranteed": 19436, + "integer division of two unsigned integers. ": 19437, + "accounts that have `role`. ": 19438, + "Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuard {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // ": 19439, + "slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction": 19440, + "slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status": 19441, + "02": 19442, + "0c": 19443, + "1b": 19444, + ":°": 19445, + ":\\n // ": 19446, + "Desc": 19447, + "];\\n": 19448, + "_pre": 19449, + "_grantRole": 19450, + "_digitalMedia": 19451, + "a50": 19452, + "n = ": 19453, + "v5": 19454, + "width": 19455, + "°:": 19456, + "•.°": 19457, + "•°:": 19458, + "\\n ) public ": 19459, + "unowned": 19460, + "returns a ": 19461, + "ToCaller": 19462, + ") {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691": 19463, + "AddressSet ": 19464, + "maxTotal": 19465, + "token that ": 19466, + "IERC20(token": 19467, + "check for ": 19468, + "the\\n // ": 19469, + "0x1": 19470, + "_ownerOf": 19471, + "tokens, ": 19472, + "ed by user": 19473, + "Index = ": 19474, + ".\\n */\\n function _isApprovedOrOwner": 19475, + "` cannot be the zero address.\\r\\n * - `": 19476, + "Interfaces": 19477, + "Self": 19478, + "0, 1, 2, ": 19479, + "typically ": 19480, + ".\\n * It ": 19481, + "\\\");\\n\\n require(\\n ": 19482, + "&&\\n ": 19483, + "src, ": 19484, + "outside ": 19485, + "er is not a ": 19486, + "; // 2": 19487, + "tempUint": 19488, + "deployer": 19489, + ") internal virtual {\\n _transfer(from, to, tokenId": 19490, + "_addresses": 19491, + "-address-uint256-}[`": 19492, + "Liquidation": 19493, + "_tokenIds": 19494, + "uint256[] memory balances": 19495, + ");\\n require(to != owner": 19496, + ", but not ": 19497, + "reasury ": 19498, + "_safeMint`], ": 19499, + "slot of the ": 19500, + "` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul": 19501, + "IERC721Receiver-onERC721Received} to ": 19502, + "safe transfer": 19503, + "\\\");\\r\\n ": 19504, + "royalty fee ": 19505, + "start of ": 19506, + "UPP": 19507, + ".\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner": 19508, + "smaller than the ": 19509, + "owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _": 19510, + "add a ": 19511, + "Destroys `amount` tokens from the caller": 19512, + "part of a ": 19513, + "with an additional ": 19514, + "`),\\n * and ": 19515, + "`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to ": 19516, + "squa": 19517, + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _": 19518, + "forwarded in {": 19519, + "{\\r\\n require(\\r\\n ": 19520, + "behavior in ": 19521, + "ApproveToCaller": 19522, + "circu": 19523, + "transfer to non ERC721Receiver implementer\"": 19524, + ");\\n\\n /// @notice The ": 19525, + "uint8) {\\n return _decimals": 19526, + "Detail": 19527, + "();\\n if (quantity == 0) revert MintZeroQuantity": 19528, + "Funding": 19529, + "ToZeroAddress();\\n if (quantity == 0) revert MintZeroQuantity": 19530, + ".*:": 19531, + ".*•´": 19532, + "At this point": 19533, + ", \\\"ERC721: approval to current owner": 19534, + "`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `": 19535, + "*.´": 19536, + "`tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner": 19537, + "parameter which ": 19538, + "(address owner, address spender, uint256 amount) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev ": 19539, + "programming ": 19540, + "if (!_exists(tokenId)) revert URIQueryForNonexistentToken": 19541, + "byte(0, ": 19542, + ".\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender": 19543, + ";\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection": 19544, + "_approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved": 19545, + "\\n view\\n returns (": 19546, + "record of ": 19547, + "batch mint": 19548, + "\\r\\n /**\\r\\n * @dev ": 19549, + "_tokenApprovals[tokenId] = to;\\n emit Approval(": 19550, + "_ALLOW": 19551, + "\\\\xe5\\\\x": 19552, + "Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and ": 19553, + "keccak256(abi.encodePacked(\\\"\\\\x19\\\\x01\\\", ": 19554, + "allowed SeaDrop contract.\\n * @param ": 19555, + ";\\n\\n/*\\n * @dev ": 19556, + "call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to ": 19557, + "e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based": 19558, + "1 word for the ": 19559, + "`data` parameter which ": 19560, + "_balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n\\n _afterTokenTransfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n unchecked {\\n _balances[account] = accountBalance - amount;\\n }\\n _totalSupply -= amount;\\n\\n emit Transfer": 19561, + "Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner": 19562, + "` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to ": 19563, + "ERC721-_safeMint-address-uint256-}[`": 19564, + ":°•.°": 19565, + "Descri": 19566, + "_safeMint`], with an additional ": 19567, + "IERC721Receiver-onERC721Received} to contract recipient": 19568, + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer": 19569, + "forwarded in {IERC721Receiver-onERC721Received} to contract recipient": 19570, + ".*•´.*:": 19571, + "Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn": 19572, + "e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer": 19573, + "Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId": 19574, + "` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer": 19575, + "ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional ": 19576, + "ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which ": 19577, + ".total": 19578, + "/\"": 19579, + "Bulk": 19580, + "CC": 19581, + "Failed": 19582, + "_gauge": 19583, + "cancel": 19584, + "eco": 19585, + "four": 19586, + "kit": 19587, + "oz": 19588, + "sg": 19589, + "s\\\":": 19590, + "xp": 19591, + "\\n ) internal virtual {\\n require(": 19592, + "orari": 19593, + "ing\\n // ": 19594, + "artist ": 19595, + "\\\") {": 19596, + "is un": 19597, + "is now ": 19598, + ".send": 19599, + "an emergency ": 19600, + "\\n * the ": 19601, + " = IUniswapV2Factory": 19602, + ". Throws if ": 19603, + "Invocation": 19604, + "value does not necessarily me": 19605, + " _____": 19606, + "0x60": 19607, + "will exceed ": 19608, + "IPancake": 19609, + "SafeTransfer": 19610, + "safeSub": 19611, + "Unlocked": 19612, + "sellTax": 19613, + "0, 0": 19614, + ".\\n * - `to` cannot be the zero address": 19615, + "scenari": 19616, + ") public virtual {\\n require(": 19617, + "rowd": 19618, + ")\\\", p0));\\n\\t\\tignored;\\n\\t}\\n\\n\\tfunction ": 19619, + "updateReward": 19620, + "multiProof": 19621, + "struct value does not necessarily me": 19622, + "p0) internal view {\\n\\t\\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature(\\\"log(": 19623, + "_msgSender());\\n }\\n\\n /**\\n * @dev ": 19624, + ", uint reserveOut": 19625, + "Bear": 19626, + "interpre": 19627, + "_totalMinted(": 19628, + "ownership details": 19629, + "admin to ": 19630, + "their own": 19631, + "||\\n ": 19632, + "APPRO": 19633, + ") {\\n _status = _NOT_ENTERED": 19634, + "values in the ": 19635, + "way to retrieve ": 19636, + "token is unowned": 19637, + "lower gas during ": 19638, + "))\\n }\\n }\\n ": 19639, + "list of the ": 19640, + "s in Solidity ": 19641, + "dstRepOld": 19642, + "malleable": 19643, + "(uint256 tokenId) public view virtual override returns (address": 19644, + "].add(addedValue": 19645, + "separately ": 19646, + "be\\n * re": 19647, + "r` and `s": 19648, + "uint256(_addressData[owner].": 19649, + "sale price": 19650, + "token/ERC721/extensions/IERC721Metadata.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../": 19651, + "LICENS": 19652, + "loop ": 19653, + "high level ": 19654, + "uint112 reserve0, ": 19655, + "modulo by zero": 19656, + "var-name-mixedcase ": 19657, + "isexemptfromfees": 19658, + "\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved": 19659, + "tokenId` must not exist.\\n * - `to` cannot be the zero address": 19660, + "launchedAt": 19661, + "structs/EnumerableSet": 19662, + "standardized way to retrieve ": 19663, + ");\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`": 19664, + ");\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `": 19665, + "DECIMAL": 19666, + "debt ": 19667, + " batch size": 19668, + "implementation for details.": 19669, + ";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n ": 19670, + "\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address": 19671, + "Burnable is Context": 19672, + "dynamicLiquidityFee": 19673, + "an the token is unowned": 19674, + "recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom": 19675, + "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff": 19676, + "if (to.isContract()) {\\n ": 19677, + "_safeMint(to, tokenId, \\\"\\\"": 19678, + ")\\n );\\n\\n // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .\\n if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {\\n uint256 nextTokenId = tokenId + 1;\\n // If the next slot's address is zero and not burned (i.e. packed value is zero).\\n if (_packedOwnerships[nextTokenId] == 0) {\\n // If the next slot is within bounds.\\n if (nextTokenId != _currentIndex) {\\n // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.\\n _packedOwnerships[nextTokenId] = prevOwnershipPacked;\\n }\\n }\\n }\\n }\\n\\n emit Transfer": 19679, + "incredibly unrealistic.\\n // ": 19680, + "An empty struct value does not necessarily me": 19681, + "divergencetech/ethier": 19682, + "_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address": 19683, + "override(ERC165, IERC165) returns (bool) {\\n return\\n interfaceId == type(IERC721).interfaceId ||\\n interfaceId == type(IERC721Metadata).interfaceId ||\\n super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner": 19684, + "Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId": 19685, + "multiProofVerify": 19686, + ") {\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and ": 19687, + "lower gas during batch mint": 19688, + "uint112 reserve0, uint112 reserve1": 19689, + "standardized way to retrieve royalty payment": 19690, + "An empty struct value does not necessarily mean the token is unowned": 19691, + " 2": 19692, + " public ": 19693, + " information": 19694, + "-only": 19695, + "Norm": 19696, + "Qty": 19697, + "_recipient": 19698, + "_hash": 19699, + "_safeTransfer": 19700, + "_srcChainId": 19701, + "`\\n ": 19702, + "e^": 19703, + "my": 19704, + "r.": 19705, + "al\\n * ": 19706, + "\\n @notice ": 19707, + ", uint32 ": 19708, + "fungi": 19709, + "versa": 19710, + "address addr": 19711, + "owner_": 19712, + "public ": 19713, + "require ": 19714, + "an overflow ": 19715, + "Adv": 19716, + "\\n\\npragma solidity >=": 19717, + "in which ": 19718, + "in bugs, ": 19719, + ". However": 19720, + "getPool": 19721, + "getChainId": 19722, + "require(denominator": 19723, + "error, which is the ": 19724, + "TokensBeforeSwap": 19725, + "Setup": 19726, + "with 0x": 19727, + ");\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId": 19728, + "bytes of ": 19729, + ";\\n }\\n\\n /**\\n * @dev Modifier to make a function callable only when the ": 19730, + "perman": 19731, + "Perp": 19732, + "RES": 19733, + "using SafeMath for uint256": 19734, + "ED ": 19735, + "ownership-": 19736, + "}.\\n */\\n function burn(uint256 amount": 19737, + "_minters": 19738, + "IUniswapV2Factory ": 19739, + "denominator, ": 19740, + "denominator == 0": 19741, + "_toAddress": 19742, + ");\\r\\n\\r\\n /**\\r\\n * @dev Returns the ": 19743, + "apply": 19744, + "Delegate ": 19745, + "gas saving": 19746, + "We need to ": 19747, + ");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which ": 19748, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../": 19749, + "write the ": 19750, + "initialization ": 19751, + "larger than ": 19752, + "because programm": 19753, + "Factor ": 19754, + "standard behavior in ": 19755, + "} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n ": 19756, + "ential ": 19757, + "` must be a ": 19758, + "ers usually ": 19759, + "is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipient": 19760, + "requestId": 19761, + "EIP712 ": 19762, + "marketingWalletUpdated": 19763, + ".\\n */\\nabstract contract AccessControl": 19764, + ".\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _": 19765, + "EIP-17": 19766, + "\\r\\n '": 19767, + "enumeration ": 19768, + "lower half order": 19769, + "domainSeparator, ": 19770, + "\\n */\\ncontract ERC721": 19771, + "ERC721.ownerOf(tokenId) == from, \\\"ERC721: ": 19772, + ") {\\n value /= 10 ** ": 19773, + ";\\n }\\n if (value >= 10 ** ": 19774, + "tackexchange.": 19775, + "assume that an overflow ": 19776, + "Handle ": 19777, + "those that ": 19778, + ");\\n\\n // Clear approvals\\n ": 19779, + "bytes32 private immutable ": 19780, + "`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address": 19781, + "token/ERC721/IERC721Receiver.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ": 19782, + "to == address(0)) revert Mint": 19783, + ";\\n }\\n}\\n\\n": 19784, + "expires": 19785, + "properly ": 19786, + "tic operations in Solidity ": 19787, + "Params memory ": 19788, + "pendle": 19789, + ";\\r\\n result += ": 19790, + "tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _": 19791, + "to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(": 19792, + "s `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address": 19793, + "starts off ": 19794, + "odd ": 19795, + "raises ": 19796, + "== 0) {\\n return 0;\\n }\\n\\n // ": 19797, + "compatible ": 19798, + "token holders to ": 19799, + "ByOwnerOr": 19800, + "outcome ": 19801, + "`SafeMath` restores this int": 19802, + "OUT_OF": 19803, + ");\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender": 19804, + "uition by ": 19805, + "on overflow. This can easily ": 19806, + ";\\r\\n }\\r\\n if (value ": 19807, + "\"Amount must be less than ": 19808, + "partial ": 19809, + "wrap on overflow. This can easily ": 19810, + "Frax": 19811, + "by subtracting the ": 19812, + "/256 bits\\n ": 19813, + "Portion": 19814, + "estima": 19815, + "Arithmetic operations in Solidity ": 19816, + "Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuard {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status": 19817, + ");\\n require(to != owner, \\\"ERC721: approval to current owner": 19818, + "programming langu": 19819, + "high level programming langu": 19820, + "in bugs, because programm": 19821, + "error, which is the standard behavior in ": 19822, + ");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipient": 19823, + "} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(": 19824, + "ers usually assume that an overflow ": 19825, + "tackexchange.com/": 19826, + "`SafeMath` restores this intuition by ": 19827, + "wrap on overflow. This can easily result": 19828, + "Arithmetic operations in Solidity wrap on overflow. This can easily result": 19829, + "in bugs, because programmers usually assume that an overflow ": 19830, + "error, which is the standard behavior in high level programming langu": 19831, + ");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients": 19832, + "`SafeMath` restores this intuition by reverting the transaction when ": 19833, + "in bugs, because programmers usually assume that an overflow raises ": 19834, + "\"ipf": 19835, + "#*": 19836, + ")/": 19837, + "+1)": 19838, + ".div": 19839, + "116": 19840, + "Because the ": 19841, + "EM": 19842, + "_;\\n ": 19843, + "_previousOwner": 19844, + "_squa": 19845, + "`bytes4(": 19846, + "b = ": 19847, + "byp": 19848, + "cred": 19849, + "might ": 19850, + "nu": 19851, + "qr": 19852, + "x^": 19853, + "x >= ": 19854, + "z_squa": 19855, + "\\n int256 constant ": 19856, + "repl": 19857, + "s <= ": 19858, + " ********": 19859, + "uint256) public ": 19860, + "trad": 19861, + "quad": 19862, + "address cannot be ": 19863, + "address receiver": 19864, + "ToSend": 19865, + ": decrement": 19866, + ",\\n uint256": 19867, + "umb": 19868, + "ERC721Burnable": 19869, + "provenance ": 19870, + "true, 0": 19871, + ") external view override returns (": 19872, + "currentBaseURI": 19873, + "length in ": 19874, + ";\\n\\n struct ": 19875, + ").\\n */\\ncontract ": 19876, + "bytes32 public ": 19877, + "\\n * ": 19878, + "supplied ": 19879, + "10%": 19880, + "\\n abi.encodePacked(": 19881, + "(_amount": 19882, + "Provid": 19883, + "180": 19884, + " != end": 19885, + "0 < ": 19886, + "\\\\_": 19887, + ".sol\\\";\\nimport \\\"@": 19888, + "Pausable ": 19889, + "Counter: decrement": 19890, + "OpenZeppelin guidelines: functions ": 19891, + "][_": 19892, + "OwnershipTransferred(address(0), ": 19893, + ",\\n address to,\\n uint256 value\\n ) internal {\\n ": 19894, + "lastClaim": 19895, + "lastUpdate": 19896, + "down ": 19897, + "0) {\\n return ": 19898, + "Use the ": 19899, + ") internal virtual {\\n _safeMint(to, tokenId, \\\"\\\"": 19900, + " = _allTokens": 19901, + "Upgradeable is ": 19902, + "_buyer": 19903, + "assembly {\\n ": 19904, + "UpdatedMax": 19905, + "\\u0027);\\n ": 19906, + "== 0) return (": 19907, + "reason.length == 0) {\\n ": 19908, + "Threshold ": 19909, + "delete token": 19910, + "(address target, bytes memory data, string memory errorMessage": 19911, + "Theore": 19912, + "_BOUND": 19913, + ") >> 128": 19914, + "} else {\\n return true": 19915, + "chedul": 19916, + "uint248": 19917, + "maximum mint": 19918, + "startTimestamp` ": 19919, + "Invariant(": 19920, + "Relay": 19921, + "ONE_36": 19922, + "804": 19923, + "Slot = ": 19924, + "Authorized": 19925, + "necessary ": 19926, + "\\n // (i.e. `ownership.addr": 19927, + ", \\\"SafeMath: modulo by zero": 19928, + "cached ": 19929, + "computedHash = _": 19930, + "(int256 a, int256 b) internal pure returns (int256": 19931, + "Requirements:\\r\\n *\\r\\n * - `": 19932, + "tradingActiveBlock": 19933, + "there is no ": 19934, + "lower than 0.5": 19935, + "256 by ": 19936, + "JSON ": 19937, + "earlySell": 19938, + "StablePool": 19939, + "signature is valid ": 19940, + ". Since the ": 19941, + "c / a != ": 19942, + "lower than 0.001": 19943, + "AAAAAAAA": 19944, + "to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer": 19945, + "O(1) time ": 19946, + ".\\n *\\n * See {ERC20-_burn}.\\n */\\n function burn(uint256 amount": 19947, + ");\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to": 19948, + "uint256) {\\n if (owner == address(0)) revert ": 19949, + "token/ERC20/extensions/draft-IERC20Permit": 19950, + ";\\n\\nimport './IERC721A": 19951, + " * 10**_decimals": 19952, + "VERY IMPORTANT: UNCOMMENT THIS LATER\\n // ": 19953, + "();\\n\\n _beforeTokenTransfers(address(0), to, startTokenId, quantity);\\n\\n // Overflows are incredibly unrealistic.\\n // ": 19954, + "token gated drop ": 19955, + "umentation for ": 19956, + "dueProtocolFee": 19957, + ".\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId": 19958, + "CONSTRUCTOR": 19959, + "reedingEvent": 19960, + "safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\"": 19961, + "[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);\\n\\n // Updates:\\n // - `address` to the owner.\\n // - `startTimestamp` to the timestamp of minting.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `quantity == 1`.\\n _packedOwnerships[startTokenId] = _packOwnershipData(\\n to,\\n _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)\\n ": 19962, + ".\\n unchecked {\\n // Updates:\\n // - `balance += quantity`.\\n // - `numberMinted += quantity`.\\n //\\n // We can directly add to the `balance` and `numberMinted`.\\n _packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);\\n\\n // Updates:\\n // - `address` to the owner.\\n // - `startTimestamp` to the timestamp of minting.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `quantity == 1`.\\n _packedOwnerships[startTokenId] = _packOwnershipData(\\n to,\\n _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)\\n ": 19963, + "(\\n bytes32 poolId,\\n address ": 19964, + "At this point `": 19965, + "to == address(0)) revert MintToZeroAddress();\\n if (quantity == 0) revert MintZeroQuantity": 19966, + "tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\"": 19967, + "s `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId": 19968, + "OpenZeppelin guidelines: functions revert ": 19969, + "== 0) return (true, 0": 19970, + "c / a != b": 19971, + "tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients": 19972, + " value: ": 19973, + " & 0x": 19974, + ".\\n */\\n ": 19975, + "2b": 19976, + "20000000": 19977, + "5a": 19978, + "Fraction": 19979, + "PT": 19980, + "Y_": 19981, + "_approved": 19982, + "_upgradeTo": 19983, + "a5": 19984, + "ption ": 19985, + "\\n emit ": 19986, + "ince": 19987, + ", token": 19988, + ", in a ": 19989, + "isValid": 19990, + "isTxLimit": 19991, + "cogn": 19992, + "ance(": 19993, + "00, 0x": 19994, + ": INSUFFICIENT": 19995, + " = new": 19996, + "FeeAmount": 19997, + "Inflation": 19998, + " to delete": 19999, + " of this ": 20000, + ") external view returns(": 20001, + "as tokens ": 20002, + "onlyRole": 20003, + "Forward": 20004, + "reduce": 20005, + "}\\n\\n if (": 20006, + "ister ": 20007, + "tokens list of the ": 20008, + "bytes32 hash": 20009, + "s[to": 20010, + "tokens,\\n * ": 20011, + "oldAddress": 20012, + "] = tokenIndex": 20013, + "`.\\n * @param _": 20014, + "have more than ": 20015, + ";\\n } catch (bytes memory reason": 20016, + "(_to": 20017, + "\\r\\n * `": 20018, + "` is a ": 20019, + "Produc": 20020, + "seller": 20021, + "collat": 20022, + "scr": 20023, + "used in the ": 20024, + "lastProcessedIndex": 20025, + "Transaction ": 20026, + "uint160 ": 20027, + "(uint256 tokenId, uint256 ": 20028, + "bufferPeriod": 20029, + "; // Update the ": 20030, + "gas cost of ": 20031, + "owner cannot ": 20032, + "delete the ": 20033, + "];\\n uint256 ": 20034, + "signer address": 20035, + "Listed": 20036, + "their own ": 20037, + "Can't ": 20038, + "protocol/": 20039, + "createPair(address tokenA, address tokenB": 20040, + "standard message ": 20041, + "AND": 20042, + "9999": 20043, + "div(sub(": 20044, + "ownedTokensIndex[tokenId": 20045, + "_startTokenId() <= ": 20046, + ";\\r\\n\\r\\n // ": 20047, + "directly access": 20048, + "aphson ": 20049, + "serial": 20050, + "\\n ) external returns (uint amountA, uint amountB": 20051, + "track ": 20052, + "eth_usd": 20053, + "Revert with a ": 20054, + "`.\\n *\\n * This function ": 20055, + "#(##": 20056, + "missing `role": 20057, + "in the set. O(1).\\n *\\n * ": 20058, + "GasLimit": 20059, + "accept ": 20060, + "returndata.length > 0) {\\n // ": 20061, + ");\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, deducting ": 20062, + "[i] = ": 20063, + "-Raphson ": 20064, + " iteration": 20065, + "ERC721A__IERC721Receiver": 20066, + "(\\n address sender,\\n address recipient,\\n uint256 ": 20067, + "\\n }\\n }\\n }\\n } else {\\n return true": 20068, + "overridden in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return ": 20069, + "could be ": 20070, + "value stored at position `index` in the set. O(1).\\n *\\n * ": 20071, + "bytes4 retval) {\\n return ": 20072, + "entialOwner": 20073, + "total amount of tokens stored by the contract": 20074, + "Newton-Raphson ": 20075, + ") {\\n if (reason.length == 0) {\\n ": 20076, + "\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev ": 20077, + "/**\\n\\t * @notice ": 20078, + ", and\\n // ": 20079, + "\\n *\\n * Emits a {Approval": 20080, + "} that allows token holders to ": 20081, + "}.\\n *\\n * Requirements:\\n *\\n * - the caller must have allowance for ": 20082, + "revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true": 20083, + " /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * ": 20084, + "1inch/": 20085, + "operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it alway": 20086, + "} and {ERC20-allowance}.\\n *\\n * Requirements:\\n *\\n * - the caller must have allowance for ": 20087, + "multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul": 20088, + "keccak256(abi.encodePacked(\\\"\\\\x19\\\\x01\\\", domainSeparator, ": 20089, + "standardized way to retrieve royalty payment information": 20090, + "to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n ": 20091, + "assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true": 20092, + "s `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(": 20093, + ";\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n ": 20094, + "Revert with a standard message ": 20095, + "bytes4 retval) {\\n return retval == ": 20096, + " /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function ": 20097, + ";\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n ": 20098, + "\"W": 20099, + "\"You ": 20100, + "-based ": 20101, + ".\\r\\n ": 20102, + ".github": 20103, + "0Out": 20104, + "D4": 20105, + "FC": 20106, + "NN": 20107, + "NO": 20108, + "Pc": 20109, + "[lastTokenId": 20110, + "_basicTransfer": 20111, + "ber of ": 20112, + "dC": 20113, + "e12": 20114, + "f7": 20115, + "gap": 20116, + "hed": 20117, + "ience ": 20118, + "past ": 20119, + "uff": 20120, + "| ": 20121, + "\\n@return ": 20122, + "repay": 20123, + "s needed to ": 20124, + "intend": 20125, + ", false": 20126, + "ital ": 20127, + "pute": 20128, + ") {\\r\\n ": 20129, + "return data ": 20130, + "index of the token": 20131, + "setBaseURI": 20132, + ";\\n }\\n }\\n}\\n\"": 20133, + "), lt(": 20134, + "msgSender = _msgSender(": 20135, + "(uint256 quantity": 20136, + "currentId": 20137, + "Approval(owner, ": 20138, + "created by ": 20139, + "tokens array": 20140, + "Live": 20141, + "allows the ": 20142, + ".\\n */\\n function _startTokenId": 20143, + "result overflow": 20144, + "``accounts": 20145, + "\\r\\n * @return ": 20146, + ")\\n returns (": 20147, + "string memory) {\\n require(": 20148, + "beforeTokenTransfers": 20149, + "ess convention": 20150, + "changes": 20151, + "RewardAmount": 20152, + ".\\n bool ": 20153, + ";\\n }\\n\\n /**": 20154, + "s a uint256 or ": 20155, + "lastTokenId = _": 20156, + "last token in the ": 20157, + "last slot (": 20158, + "signatures from ": 20159, + "; // Move the ": 20160, + "not(0": 20161, + "notEnte": 20162, + ") internal view returns (uint64": 20163, + "556": 20164, + ".\\n struct ": 20165, + "previousBalance": 20166, + "then delete the ": 20167, + " := byte(0, ": 20168, + ") public virtual override returns (bool) {\\r\\n ": 20169, + "chainId ": 20170, + "Base64": 20171, + "guess": 20172, + "deletes the ": 20173, + "Collector": 20174, + "}\\r\\n\\r\\n\\r\\n": 20175, + "_CON": 20176, + "_isExcludedFromFees[from] ": 20177, + "swapTokensForETH": 20178, + "uint256[] memory amounts": 20179, + "(uint256 a, uint256 b) internal pure returns (uint256) {\\r\\n return ": 20180, + " to the slot of the ": 20181, + ".\\n\\n // ": 20182, + "source": 20183, + "Currency": 20184, + "div(prod0, ": 20185, + "liquid": 20186, + "call{value: ": 20187, + "IERC721Receiver-onERC721Received}, which is called for each ": 20188, + "\\r\\n // ": 20189, + "\\n if (a ": 20190, + ", we store the ": 20191, + "do the ": 20192, + "Slot {\\n ": 20193, + "moved token": 20194, + "IVIS": 20195, + "to-delete token": 20196, + "PartID": 20197, + "512-bit ": 20198, + "developmentWallet": 20199, + "reserveIn, uint reserveOut": 20200, + "tokenId uint256 ID of the token to be ": 20201, + "increaseApproval": 20202, + "returning `false` on failure. This behavior is nonetheless convention": 20203, + "and does not conflict with the expectations of ERC20 ": 20204, + "Keeps ": 20205, + "token to delete is the ": 20206, + "denominator) with full precision": 20207, + "currOwnershipAddr = ": 20208, + "lpBurnEnabled": 20209, + "lpBurnFrequency": 20210, + "a gap": 20211, + ");\\n require(\\n _checkOnERC721Received": 20212, + "_ownerships[nextTokenId": 20213, + "mload(add(signature, 0x60": 20214, + "x * y": 20215, + "iteration to ": 20216, + "uniswapV2Router.WETH": 20217, + ")\\n public\\n view\\n virtual\\n override(": 20218, + "Resolution": 20219, + "given address\\n */\\n function ": 20220, + ".\\n *\\n * See {ERC20-_burn} and {ERC20-allowance}.\\n *\\n * Requirements:\\n *\\n * - the caller must have allowance for ": 20221, + "this.update": 20222, + "last token, the swap operation is unnecessary": 20223, + "last token to the slot of the ": 20224, + "decreaseApproval": 20225, + "denominator * inv = 1 mod ": 20226, + "master/contracts/": 20227, + "INTERNAL": 20228, + "\\n\\t */\\n\\tfunction ": 20229, + "(\\r\\n address from,\\r\\n address to,\\r\\n uint256 amount\\r\\n ": 20230, + "swap and pop).": 20231, + "interact with ": 20232, + "magnifiedDividend": 20233, + "When the token to delete is the ": 20234, + "_burn(_msgSender(), amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, deducting ": 20235, + "To prevent a gap": 20236, + "contents at the last ": 20237, + "position of the array": 20238, + "address(0) && ownership.burned == false`)\\n // ": 20239, + "tokenIndex] = lastTokenId": 20240, + "Seconds.add(days30.mul(": 20241, + "Extension of {ERC20} that allows token holders to ": 20242, + "This also deletes the ": 20243, + "address signer = ecrecover(hash, v, r, s": 20244, + "Pendle": 20245, + "Emit an event ": 20246, + "if (!_exists(tokenId)) revert URIQueryForNonexistentToken();\\n\\n ": 20247, + ". Throws if result overflow": 20248, + "Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return ": 20249, + "ownership-tracking data structures": 20250, + "quadrati": 20251, + "OpenZeppelin guidelines: functions revert instead": 20252, + "cognized ": 20253, + "] = tokenIndex; // Update the ": 20254, + "to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer": 20255, + "assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev ": 20256, + "s `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer": 20257, + "index of the token to delete": 20258, + "tokens array, we store the ": 20259, + "s a uint256 or denominator == 0": 20260, + "last token in the index of the token to delete": 20261, + "last slot (swap and pop).": 20262, + "; // Move the last token to the slot of the ": 20263, + "then delete the last slot (swap and pop).": 20264, + "IERC721Receiver-onERC721Received}, which is called for each safe transfer": 20265, + "denominator) with full precision. Throws if result overflow": 20266, + "When the token to delete is the last token, the swap operation is unnecessary": 20267, + "contents at the last position of the array": 20268, + "This also deletes the contents at the last position of the array": 20269, + "] = tokenIndex; // Update the moved token": 20270, + "tokens array, we store the last token in the index of the token to delete": 20271, + "; // Move the last token to the slot of the to-delete token": 20272, + "denominator) with full precision. Throws if result overflows a uint256 or denominator == 0": 20273, + "\"ECDSA: invalid signature ": 20274, + "(\\n _": 20275, + "1 = ": 20276, + "1Out": 20277, + "1) {\\n ": 20278, + "2*": 20279, + "D8": 20280, + "LD": 20281, + "arn": 20282, + "sold": 20283, + "vice ": 20284, + "wSqueeth": 20285, + "\\n {\\n require(": 20286, + "toUint256": 20287, + "edAmount": 20288, + "desp": 20289, + "detection": 20290, + "\\n require(": 20291, + "owner = ": 20292, + "show": 20293, + "primiti": 20294, + "(address newImplementation": 20295, + "whiteList": 20296, + "AmountIn": 20297, + "getReward": 20298, + ";\\n }\\n\\n // ": 20299, + "s the order of the ": 20300, + "private _": 20301, + "mintPrice": 20302, + ") external {\\n require(msg.sender == ": 20303, + "onlyTeam": 20304, + ") public onlyOwner {\\r\\n ": 20305, + "Existing": 20306, + "token contract ": 20307, + "token count": 20308, + "checks": 20309, + "ote(": 20310, + "Minters": 20311, + "'s lif": 20312, + "(\\n bytes32[] calldata proof": 20313, + ").code.length": 20314, + "foo": 20315, + " ": 20316, + "_AMP": 20317, + ";\\n }\\n\\n // ": 20318, + "amount + ": 20319, + "can be re": 20320, + "s to O(1) ": 20321, + "Chin": 20322, + "transfer tokens ": 20323, + "}.\\n */\\n function at(": 20324, + "prod0.": 20325, + "user's ": 20326, + "discount": 20327, + "has O(1) time ": 20328, + "ERC721A.sol\"": 20329, + "Most ": 20330, + "pool_": 20331, + "27, ": 20332, + "one of the ": 20333, + "s for each ": 20334, + "s = 0;\\n ": 20335, + "Type.": 20336, + ");\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length": 20337, + ", but alter": 20338, + ") external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool": 20339, + "v2/contracts/": 20340, + "Balance = address(this).balance": 20341, + "tickUpper": 20342, + "tickLower": 20343, + "value is a ": 20344, + "Accounts": 20345, + "balanceOf(address account) external view returns (uint256": 20346, + "ownedTokens[from][": 20347, + "equals ": 20348, + "LIST": 20349, + ". That ": 20350, + "/// @solidity memory-safe-assembly\\n ": 20351, + "tokens and those that ": 20352, + "remove a token ": 20353, + "UpdateUniswapV2Router": 20354, + "Distributed": 20355, + "moves to O(1) ": 20356, + "Overflow not possible": 20357, + "tokens of at least\\n * `amount`.\\n */\\n function burnFrom(address account, uint256 amount) public virtual ": 20358, + "rateProvider": 20359, + "math/Math.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard ": 20360, + "The address of the owner": 20361, + "RATE_": 20362, + "MintableBy": 20363, + "/=lib/forge-std": 20364, + "here starts off ": 20365, + "A03": 20366, + "such that it is ": 20367, + "spent here starts off ": 20368, + "to == address(0)) revert ": 20369, + "Private function to add a ": 20370, + "Private function to remove a token ": 20371, + "uint256 result) {\\n ": 20372, + ", this is the ": 20373, + "\\n * - `": 20374, + "256 bit number ": 20375, + ") external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved": 20376, + ") of supply": 20377, + "Make sure the ": 20378, + "Reentrancy protection": 20379, + ";\\n uint256 end = ": 20380, + "_allowances[sender][_msgSender()].sub(amount, \\\"ERC20: transfer amount exceeds allowance\\\")": 20381, + "_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, \\\"ERC20: transfer amount exceeds allowance\\\")": 20382, + "doubling the ": 20383, + "Original ": 20384, + "roles[role].adminRole": 20385, + ") public virtual {\\n _burn(_msgSender(), amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, deducting ": 20386, + ") internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length": 20387, + "complexity, but alter": 20388, + "TokenSupplyFor": 20389, + "Rocket": 20390, + "(\\n uint amountIn,\\n uint amountOutMin,\\n address[] calldata path,\\n address to,\\n uint deadline\\n ": 20391, + ")\\n private\\n view\\n returns (": 20392, + ");\\n\\n _beforeTokenTransfer(owner, address(0), tokenId": 20393, + "path[0] = address(this": 20394, + "destroy both ": 20395, + "gradually moves to O(1) ": 20396, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\"": 20397, + "token/ERC721/IERC721Receiver.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721Receiver {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `": 20398, + ".\\n *\\n * See {ERC20-_burn}.\\n */\\n function burn(uint256 amount) public virtual {\\n _burn(_msgSender(), amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, deducting ": 20399, + "owner cannot have more than ": 20400, + "[lastTokenId] = tokenIndex; // Update the moved token": 20401, + "tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token": 20402, + "vice versa": 20403, + "s the order of the _": 20404, + "has O(1) time complexity, but alter": 20405, + "math/Math.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math": 20406, + "Private function to add a token to ": 20407, + "Private function to remove a token from ": 20408, + ") external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool": 20409, + ") internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(": 20410, + "gradually moves to O(1) as tokens ": 20411, + "has O(1) time complexity, but alters the order of the _": 20412, + "\"T": 20413, + "\"@openzeppelin/": 20414, + "'v": 20415, + "(and not ": 20416, + "(IERC20 ": 20417, + ",{\\\"": 20418, + ".\\n * @dev ": 20419, + "0/": 20420, + "BAA": 20421, + "KE": 20422, + "Layer": 20423, + "Ob": 20424, + "PHI": 20425, + "_setApprovalForAll": 20426, + "_revokeRole": 20427, + "_creator": 20428, + "f, r": 20429, + "m to ": 20430, + "v != ": 20431, + "v`, `": 20432, + "\\nlibrary ": 20433, + "algorithm": 20434, + "\\n *\\n * - `": 20435, + "uint(": 20436, + ", only ": 20437, + ", tokenB": 20438, + "function. ": 20439, + "esting ": 20440, + ") ratio": 20441, + "allTokens array": 20442, + "co B": 20443, + "emen ": 20444, + "ici": 20445, + "= `": 20446, + "amount of the ": 20447, + "sea": 20448, + "address constant ": 20449, + "address msgSender = _msgSender(": 20450, + "ToTransfer": 20451, + "may": 20452, + "require (": 20453, + "Trait": 20454, + "loemen ": 20455, + " = tokenId": 20456, + "--2-": 20457, + "(address _from": 20458, + "for v": 20459, + "ERC721Creator": 20460, + "getTotal": 20461, + "provenanceHash": 20462, + "senderBalance = ": 20463, + "onlyPauser": 20464, + "key, ": 20465, + "token tracking data structures": 20466, + "tart ": 20467, + "paper ": 20468, + "when token was burned": 20469, + "for, in a ": 20470, + "event analysis": 20471, + "aution": 20472, + "buyTreasuryFee": 20473, + "hashes": 20474, + "` cannot be greater than ": 20475, + "sell ": 20476, + "types": 20477, + "\\\\____": 20478, + "therefo": 20479, + "__gap": 20480, + ".sol)\\r\\n\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\n": 20481, + ");\\r\\n}\\r\\n\\r\\n": 20482, + "signed approval": 20483, + "proof[i]": 20484, + "approve from ": 20485, + " `value": 20486, + "fee is ": 20487, + "get transferred ": 20488, + "then it ": 20489, + "We will ": 20490, + "nonReentrantBefore": 20491, + "nonReentrantAfter": 20492, + "way that can ": 20493, + "if (!_checkContractOnERC721Received": 20494, + ", bytes32 leaf": 20495, + "Remco B": 20496, + ")\\n {\\n // ": 20497, + "automatedMarketMakerPairs\"": 20498, + "return true;\\n }\\n\\n function ": 20499, + "royaltyFraction": 20500, + "_FOR": 20501, + "284": 20502, + "28, ": 20503, + "authoriz": 20504, + "` must be a valid ": 20505, + "customRevert": 20506, + "curr = tokenId": 20507, + "quantity - the amount to be transferred": 20508, + "v2.": 20509, + "UNLICENS": 20510, + "covered ": 20511, + "ptr := add(": 20512, + "\\\");\\n _safeTransfer": 20513, + "track the ": 20514, + "bits of the ": 20515, + "srcRepNew": 20516, + "Authorization": 20517, + "most significant": 20518, + "computedHash, ": 20519, + "startTokenId - the first ": 20520, + "an allowance for, in a ": 20521, + "onlyRole(DEFAULT_ADMIN_ROLE": 20522, + "AutoNukeLP": 20523, + "_initializing ": 20524, + "See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(": 20525, + ";\\n if (": 20526, + "667": 20527, + "token id to be transferred": 20528, + "\\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n ": 20529, + "Gas spent here starts off ": 20530, + "formatted ": 20531, + "afterTokenTransfers(\\n address from,\\n address to,\\n uint256 startTokenId,\\n uint256 quantity\\n ": 20532, + "Virtual": 20533, + ") return (false, 0);\\n return (true, c": 20534, + "\\n * @param tokenId uint256 ID of the token to be ": 20535, + "global default": 20536, + "render": 20537, + "off-chain (via ": 20538, + "migration": 20539, + "; ++i) {\\n ": 20540, + "```\\n * contract ": 20541, + "if (b == 0) return (false, 0);\\n return (true, ": 20542, + "(\\n address from,\\n address to,\\n uint256 startTokenId,\\n uint256 quantity\\n ) internal virtual {}\\n\\n /**\\n * @dev Hook that is called after ": 20543, + "`to`.\\r\\n * - ": 20544, + "token ids via {": 20545, + "including the Enumerable extension": 20546, + "emit OwnershipTransferred(_owner, address(0)": 20547, + "_00_00": 20548, + "convertTo": 20549, + "r := shr(f, r": 20550, + "the fee denominator": 20551, + "(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes": 20552, + "ERC2981: royalty fee ": 20553, + "pair cannot be removed from automatedMarketMakerPairs\"": 20554, + "absTick & 0x": 20555, + "xn--2-": 20556, + "Now that ": 20557, + "), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev ": 20558, + "therwise": 20559, + "they have an allowance for, in a ": 20560, + "proportional to the maximum mint": 20561, + ".swapExactTokensForETHSupportingFeeOnTransferTokens": 20562, + "Amplification": 20563, + ");\\n return (spender == owner || ": 20564, + ") {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\\n return ": 20565, + ", but not including the Enumerable extension": 20566, + "start of ownership": 20567, + "will exceed salePrice": 20568, + "lower gas during batch mints.\\n *\\n * ": 20569, + "umb.com/": 20570, + "tokens list of the given address\\n */\\n function ": 20571, + "keccak256(abi.encodePacked(\\\"\\\\x19\\\\x01\\\", domainSeparator, structHash": 20572, + "beforeTokenTransfers(\\n address from,\\n address to,\\n uint256 startTokenId,\\n uint256 quantity\\n ) internal virtual {}\\n\\n /**\\n * @dev Hook that is called after ": 20573, + " := byte(0, mload(add(signature, 0x60": 20574, + "cognized off-chain (via ": 20575, + "Chinese ": 20576, + "tokens and those that they have an allowance for, in a ": 20577, + "destroy both their own": 20578, + "gradually moves to O(1) as tokens get transferred ": 20579, + "LayerZero ": 20580, + "` cannot be greater than the fee denominator": 20581, + "Remco Bloemen ": 20582, + "most significant bit": 20583, + "startTokenId - the first token id to be transferred": 20584, + "Gas spent here starts off proportional to the maximum mint": 20585, + "ERC2981: royalty fee will exceed salePrice": 20586, + "xn--2-umb.com/": 20587, + "cognized off-chain (via event analysis": 20588, + "tokens and those that they have an allowance for, in a way that can ": 20589, + "gradually moves to O(1) as tokens get transferred around ": 20590, + "Gas spent here starts off proportional to the maximum mint batch size": 20591, + "\"operator-filter-registry/src/": 20592, + "(address,": 20593, + ".increment": 20594, + "/mul": 20595, + "2._\\n */\\n function ": 20596, + "6AF": 20597, + "7 iteration": 20598, + "8e": 20599, + "BO": 20600, + "DO": 20601, + "Daily": 20602, + "Hence": 20603, + "IJB": 20604, + "Launch": 20605, + "OFT": 20606, + "_PO": 20607, + "closed": 20608, + "vol": 20609, + ", doubling the ": 20610, + ") revert(": 20611, + "trade": 20612, + "ing\\r\\n * ": 20613, + "= IUniswapV2Router02": 20614, + "is no longer ": 20615, + "` event": 20616, + "` as ": 20617, + "assigned ": 20618, + "\\n function mint": 20619, + ": cannot ": 20620, + "data s": 20621, + "ma, this ": 20622, + "RevShare": 20623, + "open ": 20624, + " = 128": 20625, + "spender ": 20626, + "in each step": 20627, + "not yet ": 20628, + "Invert ": 20629, + "and prod1": 20630, + ";\\n } catch (bytes memory reason": 20631, + " to add": 20632, + "from prod1 ": 20633, + "from [prod1 prod0": 20634, + "from 512 bit ": 20635, + "by starting ": 20636, + "address(uint160": 20637, + ", uint256 royaltyAmount": 20638, + "This contract ": 20639, + "burning one ": 20640, + "address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId": 20641, + "ting lem": 20642, + "\\n // this ": 20643, + "actionId": 20644, + "result and prod1": 20645, + "` is not ": 20646, + "Sets `": 20647, + "sellTreasuryFee": 20648, + "0, twos), ": 20649, + "s to Hen": 20650, + "ast significant 256 bits of the product": 20651, + ".\\n * - `quantity` must be greater than 0": 20652, + "ditions ": 20653, + "Burned(": 20654, + "`tokenId` has be": 20655, + "using mulmod": 20656, + "ource": 20657, + "sel's lif": 20658, + "result. The result is ": 20659, + ");\\n if (": 20660, + "number, it ": 20661, + "numberBurned ": 20662, + "_balances[msg.sender": 20663, + "(from, address(0), ": 20664, + "denominator := div(": 20665, + "denominator is an ": 20666, + "non-overflow ": 20667, + "Cond": 20668, + "marketingAddress": 20669, + "zero, then it ": 20670, + "(\\n address from,\\n address to,\\n ": 20671, + "ed in basis point": 20672, + "two 256": 20673, + "two divisor ": 20674, + "two out of ": 20675, + "one token has been burned": 20676, + "implementation of the ": 20677, + "; // Le": 20678, + "; // Most ": 20679, + "valid range ": 20680, + "`owner`\\n * ": 20681, + "(). ": 20682, + ") {\\n require(!": 20683, + "sub(mm, prod0": 20684, + " bits. That ": 20685, + "minted in the contract": 20686, + "guy": 20687, + "claimer": 20688, + "uint64) of supply": 20689, + "\\n ) external virtual ": 20690, + "also work": 20691, + "with the modular ": 20692, + "result = prod0": 20693, + "number of tokens burned": 20694, + "_COR": 20695, + "ACT": 20696, + "ect square": 20697, + "let mm": 20698, + "inverse of denominator": 20699, + "inverse by starting ": 20700, + "available separately ": 20701, + "division exact ": 20702, + "division is now ": 20703, + "before burning one ": 20704, + "_ \\\\": 20705, + "after one token has been burned": 20706, + "Create": 20707, + "ve the precision": 20708, + ".\\r\\n *\\r\\n * Emits a {Transfer} event": 20709, + "Shutdown": 20710, + "largest power of ": 20711, + "Balance = balanceOf(address(this)": 20712, + "checkpoint ": 20713, + "prod0; // Le": 20714, + "start time of ": 20715, + "ways >= ": 20716, + ", as _burnCounter cannot be ": 20717, + "libraries ": 20718, + "prod1, gt(": 20719, + "prod1; // Most ": 20720, + ")) {\\n ": 20721, + ");\\n }\\n }\\n ": 20722, + "Target ": 20723, + "Copyright ": 20724, + "bits in each step": 20725, + "bits from prod1 ": 20726, + "FEE_D": 20727, + "twos = ": 20728, + "twos is ": 20729, + "));\\n bytes32 ": 20730, + "with a seed ": 20731, + "ERC721Enumerable}.": 20732, + "exceed _currentIndex ": 20733, + "anks to Hen": 20734, + "correct result ": 20735, + "correct bits in each step": 20736, + "it to Remco Bloemen ": 20737, + ", which is available separately ": 20738, + "s {\\n struct ": 20739, + "arithmetic, doubling the ": 20740, + "prod0 := sub(": 20741, + "prod0 |= ": 20742, + ";\\n emit Approval(owner, to, tokenId": 20743, + "passed ": 20744, + "512 by ": 20745, + "remainder, prod0": 20746, + "a08": 20747, + ", please override this function": 20748, + "arguments.": 20749, + "^ 2": 20750, + ":= add(div(sub(": 20751, + "remainder := ": 20752, + "remainder from [prod1 prod0": 20753, + "remainder using mulmod": 20754, + "21/mul": 20755, + "if (b > a": 20756, + "Price * ": 20757, + "_burnCounter++": 20758, + "such that product = ": 20759, + "exact we can ": 20760, + "use the Chinese ": 20761, + "Calculates floor": 20762, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/": 20763, + "high bits of the ": 20764, + "denominator) ^ 2": 20765, + "xCVX": 20766, + "[prod1 prod0] ": 20767, + "[prod1 prod0] = ": 20768, + ") {\\n if (reason.length": 20769, + "PRICE": 20770, + "final result": 20771, + "s `quantity` tokens and transfers them to `to`.\\n *\\n * Requirements:\\n *\\n * - ": 20772, + "There will always ": 20773, + " been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account": 20774, + "\\x01": 20775, + "compute the high bits of the ": 20776, + "2098 ": 20777, + ").\\r\\n *\\r\\n * Counterpart to Solidity's `": 20778, + "variables such that product = ": 20779, + "Divide denominator ": 20780, + "Divide [prod1 prod0] ": 20781, + "Make division exact ": 20782, + "total amount of tokens minted in the contract": 20783, + ");\\n }\\n\\n /**\\n * @dev Safely mints `quantity` tokens and transfers them to `to`.\\n *\\n * Requirements:\\n *\\n * - ": 20784, + "prod0, remainder": 20785, + " - 1 (max value of uint64) of supply": 20786, + "prod1 * twos": 20787, + "prod1 := sub(sub(mm, prod0": 20788, + "prod1 := sub(prod1, gt(": 20789, + "prod0 := div(prod0, ": 20790, + "512 bit result. The result is ": 20791, + "_burnCounter cannot be increment": 20792, + "CANONICAL_OPERATOR_FILTER_REGISTRY": 20793, + "twos := add(div(sub(": 20794, + "under MIT license ": 20795, + "Linear": 20796, + "t in bits from prod1 ": 20797, + "multiply [prod1 prod0] = ": 20798, + "2**64 - 1 (max value of uint64) of supply": 20799, + "allowedNftToken": 20800, + ".startTimestamp = uint64(block.timestamp": 20801, + "tokens list\\n */\\n function ": 20802, + "improve the precision": 20803, + "Whether the token has been burned": 20804, + "perfect square": 20805, + "];\\n\\n // When the token to delete is the last token, the swap operation is unnecessary": 20806, + "\\n\\n uint256 lastTokenIndex": 20807, + "is, denominator * inv = 1 mod ": 20808, + "don't need to compute the high bits of the ": 20809, + "stored in two 256": 20810, + ";\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\"": 20811, + "Compute remainder using mulmod": 20812, + "computedHash = leaf": 20813, + "3 * denominator) ^ 2": 20814, + "try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (": 20815, + "By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200)\\n _status = _NOT_ENTERED;\\n }\\n}\\n\"": 20816, + "on SeaDrop.\\n * Only ": 20817, + "Subtract 256 bit number ": 20818, + "powers of two out of ": 20819, + "Remainder Theore": 20820, + "Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the\\n * zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId": 20821, + "cases, 256 by ": 20822, + "(account, address(0), amount);\\n\\n _afterTokenTransfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(\\n address owner,\\n address spender,\\n uint256 amount\\n ) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Updates `owner` s allowance for `spender` based on spent `amount`.\\n *\\n * Does not update the allowance amount in case of infinite allowance.\\n * Revert if not enough allowance is available.\\n *\\n * Might emit an {Approval} event.\\n */\\n function _spendAllowance(\\n address owner,\\n address spender,\\n uint256 amount\\n ) internal virtual {\\n uint256 currentAllowance = allowance(owner, spender);\\n if (currentAllowance != type(uint256).max) {\\n require(currentAllowance >= amount, \\\"ERC20: insufficient allowance\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - amount);\\n }\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {}\\n\\n /**\\n * @dev Hook that is called after any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * has been transferred to `to`.\\n * - when `from` is zero, `amount` tokens have been minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {}\\n}\\n\"": 20823, + ") internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received": 20824, + "four bits. That ": 20825, + "Normal": 20826, + "Factor powers of two out of ": 20827, + "Handle non-overflow ": 20828, + "odd number, it ": 20829, + "by subtracting the remainder from [prod1 prod0": 20830, + "Because the division is now ": 20831, + "OwnershipTransferred(address(0), msgSender": 20832, + "Newton-Raphson iteration to ": 20833, + ", and\\n // then delete the last slot (swap and pop).": 20834, + "), lt(mm, prod0": 20835, + "512-bit multiply [prod1 prod0] = ": 20836, + "Extension of {ERC20} that allows token holders to destroy both their own": 20837, + "quadratically ": 20838, + "IERC721Receiver-onERC721Received}, which is called for each safe transfer.\\n * - `quantity` must be greater than 0": 20839, + "tokens array, we store the last token in the index of the token to delete, and\\n // then delete the last slot (swap and pop).": 20840, + "Overflow not possible, as _burnCounter cannot be ": 20841, + ", this is the final result": 20842, + "Make sure the result is ": 20843, + "owner cannot have more than 2**64 - 1 (max value of uint64) of supply": 20844, + "senderBalance = _balances[sender": 20845, + "UNLICENSED": 20846, + "Now that denominator is an ": 20847, + ", but not including the Enumerable extension, which is available separately ": 20848, + "xn--2-umb.com/21/mul": 20849, + "cognized off-chain (via event analysis).": 20850, + "is no longer required": 20851, + "ma, this also work": 20852, + "Invert denominator ": 20853, + ";\\n } catch (bytes memory reason) {\\n if (reason.length": 20854, + "from 512 bit number": 20855, + "ting lemma, this also work": 20856, + "0, twos), twos), ": 20857, + "sel's lifting lemma, this also work": 20858, + "numberBurned += 1": 20859, + "denominator := div(denominator, ": 20860, + "zero, then it becomes ": 20861, + "two divisor of denominator": 20862, + "with the modular inverse of denominator": 20863, + "result = prod0 * ": 20864, + "let mm := ": 20865, + "inverse by starting with a seed ": 20866, + "before burning one token": 20867, + "largest power of two divisor of denominator": 20868, + "prod0; // Least significant 256 bits of the product": 20869, + "start time of ownership ": 20870, + "prod1; // Most significant 256 bits of the product": 20871, + "twos is zero, then it becomes ": 20872, + "anks to Hensel's lifting lemma, this also work": 20873, + "it to Remco Bloemen under MIT license ": 20874, + "arithmetic, doubling the correct bits in each step": 20875, + "prod0 := sub(prod0, remainder": 20876, + "prod0 |= prod1 * twos": 20877, + "512 by 256 division": 20878, + "exact we can divide by ": 20879, + "use the Chinese Remainder Theore": 20880, + "There will always be an ": 20881, + "variables such that product = prod1 * ": 20882, + "Make division exact by subtracting the remainder from [prod1 prod0": 20883, + "prod1 := sub(sub(mm, prod0), lt(mm, prod0": 20884, + "prod1 := sub(prod1, gt(remainder, prod0": 20885, + "512 bit result. The result is stored in two 256": 20886, + "CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS": 20887, + "twos := add(div(sub(0, twos), twos), ": 20888, + "t in bits from prod1 into ": 20889, + "perfect square, the ": 20890, + "don't need to compute the high bits of the result and prod1": 20891, + "Subtract 256 bit number from 512 bit number": 20892, + "cases, 256 by 256 division": 20893, + "four bits. That is, denominator * inv = 1 mod ": 20894, + "Factor powers of two out of denominator": 20895, + "Handle non-overflow cases, 256 by 256 division": 20896, + "odd number, it has an ": 20897, + "Because the division is now exact we can divide by ": 20898, + "Newton-Raphson iteration to improve the precision": 20899, + "tokens array, we store the last token in the index of the token to delete, and\\n // then delete the last slot (swap and pop).\\n\\n uint256 lastTokenIndex": 20900, + "Overflow not possible, as _burnCounter cannot be exceed _currentIndex ": 20901, + "Now that denominator is an odd number, it has an ": 20902, + ", but not including the Enumerable extension, which is available separately as": 20903, + "xn--2-umb.com/21/muldiv": 20904, + ";\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n ": 20905, + "inverse by starting with a seed that is ": 20906, + "use the Chinese Remainder Theorem to ": 20907, + "#specification": 20908, + "&@": 20909, + "-re": 20910, + ".\\n * @return ": 20911, + "/#": 20912, + "227": 20913, + "2bb": 20914, + "CD0": 20915, + "Eye": 20916, + "Kar": 20917, + "Net": 20918, + "Penal": 20919, + "SPDX-License-Identifier: ": 20920, + "Yel": 20921, + "[_msgSender()": 20922, + "[address(this)": 20923, + "_partition": 20924, + "bonus": 20925, + "boughtEarly": 20926, + "f6": 20927, + "ki": 20928, + "lect ": 20929, + "pred": 20930, + "q/": 20931, + "son": 20932, + "v from ": 20933, + "alici": 20934, + "s will be ": 20935, + "encode ": 20936, + "to\\n // the ": 20937, + ", a": 20938, + "acon ": 20939, + "uint256. ": 20940, + "**/": 20941, + "// only ": 20942, + "Id(": 20943, + "or on behalf of `owner": 20944, + "ERC20(": 20945, + "\\n * roles": 20946, + "tokenId_": 20947, + "share ": 20948, + "for s in ": 20949, + "3210": 20950, + "getCurrent": 20951, + "Return ": 20952, + "require(hasRole(": 20953, + "Of(address addr) external returns (": 20954, + "s.\\n ": 20955, + "onlyOwnerOr": 20956, + "are not ": 20957, + "this possibility ": 20958, + "swapTokens": 20959, + "paye": 20960, + "\\\");\\n if (": 20961, + "safe96": 20962, + "(\\n address seaDropImpl": 20963, + ";\\n address private ": 20964, + ";\\n bool private ": 20965, + "buyCount": 20966, + "revert OwnerQueryForNonexistentToken": 20967, + "Proof ": 20968, + "data = ": 20969, + "roles, ": 20970, + "\\n /// @notice ": 20971, + " > prod1": 20972, + "AL_EXPONENT": 20973, + ";\\r\\n\\t": 20974, + "(tokenId);\\n } else if (": 20975, + ");\\n }\\n\\n /**\\n * Returns the ": 20976, + "Number of ": 20977, + "RateCache": 20978, + "Post": 20979, + "generate a ": 20980, + "find ": 20981, + "receiver` cannot be the zero address.\\n * - `": 20982, + "string,uint": 20983, + "without the ": 20984, + "chainlink": 20985, + ", uint reserveIn, uint reserveOut": 20986, + "does not decrement": 20987, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.0 (": 20988, + "_NATUR": 20989, + "tokenA, tokenB": 20990, + "A helper ": 20991, + "_currentIndex = _startTokenId": 20992, + ",\\n bytes32 leaf": 20993, + "being emitted ": 20994, + "excludedFrom": 20995, + "s.length; i++) {\\n ": 20996, + ";\\n\\t\\t": 20997, + "editionSize": 20998, + "Votes(address account": 20999, + "delete _owners[tokenId": 21000, + "Exceeds ": 21001, + "flag ": 21002, + "Flip ": 21003, + "shares_": 21004, + ".\\n * @param tokenId uint256 ID of the token to be ": 21005, + "any\\n * ": 21006, + "overriding the ": 21007, + "Invariant:": 21008, + ";\\n // Keeps ": 21009, + "multiple times": 21010, + "Returns an Ethereum Signed ": 21011, + "[msg.sender] ": 21012, + "\"ERC721: transfer to non ERC721Receiver implementer\"": 21013, + "ln(a": 21014, + "1): ": 21015, + "mintingFinished": 21016, + "firstBlock": 21017, + "`account`.\\n *\\n * Internal function without access restriction": 21018, + "//\\n// ": 21019, + "2**256 - 1 (max value of ": 21020, + ";\\n uint256 private immutable _": 21021, + "sequently": 21022, + "Not enough ": 21023, + "];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf": 21024, + "a == 0 ? 0 : ": 21025, + "burned by or on behalf of `owner": 21026, + ").\\n */\\n function _get": 21027, + "additionalPayeeSecondarySales": 21028, + "split ": 21029, + "security/ReentrancyGuard.sol\"": 21030, + "),\\n \\\"ERC721: transfer to non ERC721Receiver implementer": 21031, + "E_PRECISION": 21032, + "_burnCounter - ": 21033, + "enforced by the ": 21034, + "s `quantity` tokens and transfers them to `to`": 21035, + "name, _symbol": 21036, + "onlyAllowedOperatorApproval(operator": 21037, + "and it is initialized to ": 21038, + "_balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf": 21039, + ") public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: ": 21040, + "secp256k1` ": 21041, + "secp256k1n ": 21042, + "paper/": 21043, + "_operationsFee": 21044, + "senderBalance - amount": 21045, + "Aux(address owner, uint64 ": 21046, + "Aux(address owner) internal view returns (uint64": 21047, + ";\\n\\n // Mapping owner address to token count": 21048, + "this extension's ownership-tracking data structures": 21049, + "(_from, _to, ": 21050, + ");\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n ": 21051, + "UniswapV2Library.pairFor": 21052, + ",\\n bytes32 root,\\n bytes32 leaf": 21053, + "() internal view virtual returns (uint256) {\\n return 0": 21054, + "v3-": 21055, + "cannot exceed 2**256 - 1 (max value of ": 21056, + "set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev ": 21057, + "For more information ": 21058, + "making it call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant(": 21059, + "ROYAL": 21060, + "_PROJEC": 21061, + "`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients": 21062, + ");\\n }\\n\\n /**\\n * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\\n */\\n function toHexString(address addr) internal pure returns (string memory) {\\n return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\\n }\\n}\\n\"": 21063, + "messaging library ": 21064, + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n uint256 c = a + b;\\n require(c >= a, \\\"SafeMath: addition overflow": 21065, + "_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: ": 21066, + "\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address": 21067, + " 2 + 1": 21068, + ");\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients": 21069, + "VERY IMPORTANT: UNCOMMENT THIS LATER\\n // VERY IMPORTANT: UNCOMMENT THIS LATER\\n // ": 21070, + "scratch ": 21071, + ".github.io/": 21072, + "``accounts``'s ": 21073, + "'v' value": 21074, + "valid range for s in ": 21075, + "ways >= 1": 21076, + "Yellow ": 21077, + "_NATURAL_EXPONENT": 21078, + "),\\n \\\"ERC721: transfer to non ERC721Receiver implementer\\\"\\n ": 21079, + "Aux(address owner, uint64 aux": 21080, + ";\\n\\n // Mapping owner address to token count\\n ": 21081, + "UniswapV2Library.pairFor(factory": 21082, + "cannot exceed 2**256 - 1 (max value of uint256": 21083, + "% and ": 21084, + ")=": 21085, + ".pdf": 21086, + "/28, ": 21087, + "52": 21088, + "BE": 21089, + "Cardinality": 21090, + "IToken": 21091, + "I_SUBSCRIPTION": 21092, + "Kit": 21093, + "LIN": 21094, + "_withdraw": 21095, + "`leaves": 21096, + "`secp256k1` ": 21097, + "hh": 21098, + "ron": 21099, + "s1 and ": 21100, + "tb": 21101, + "v to ": 21102, + "yel": 21103, + "z = ": 21104, + "÷ 2 + 1": 21105, + "inflation": 21106, + ", length": 21107, + "ous": 21108, + "25E8": 21109, + ") or ": 21110, + ");\\r\\n ": 21111, + "function arguments.": 21112, + "a part of a ": 21113, + ": r": 21114, + ": v ": 21115, + "wait ": 21116, + "transferAmount": 21117, + "ify ": 21118, + "bytes(_": 21119, + "in any other ": 21120, + "not burned": 21121, + ". It ": 21122, + "indexIn": 21123, + "and make the ": 21124, + "setRoleAdmin": 21125, + "private key": 21126, + "), defin": 21127, + "), return the ": 21128, + "as a s": 21129, + "cliff": 21130, + "a swap": 21131, + "lowpaper/": 21132, + "Caller ": 21133, + "its by ": 21134, + "'s method ": 21135, + "mapping, ": 21136, + "INT": 21137, + "(_name, _symbol": 21138, + "If your library ": 21139, + "tax ": 21140, + "interface of ": 21141, + "EDCE": 21142, + "240": 21143, + "timestamp in the ": 21144, + ", and for v": 21145, + "current libraries ": 21146, + "denominator + 1": 21147, + "BBFD": 21148, + ".\\n address addr": 21149, + "manu": 21150, + "ethereum.github.io/": 21151, + ".length; i++": 21152, + "Mode ": 21153, + "s-value": 21154, + "s-value in the ": 21155, + "s-values in the ": 21156, + "proof.length; i++) {\\n ": 21157, + "27/28, ": 21158, + ") internal view virtual {\\n ": 21159, + "depend": 21160, + "signatures with ": 21161, + "ECON": 21162, + "tokensForTreasury": 21163, + "signature with an ": 21164, + "signature malle": 21165, + "was signed by the ": 21166, + "flip ": 21167, + "our target ": 21168, + "these malleable ": 21169, + "98d": 21170, + "981 ": 21171, + "operation did not succeed": 21172, + "ERC20 operation did not succeed": 21173, + "_checkpoints": 21174, + "also generates ": 21175, + ");\\n\\n // Overflow not possible, as _burnCounter cannot be exceed _currentIndex ": 21176, + "write it ": 21177, + "ased on ": 21178, + ",\\n string memory _symbol": 21179, + ";\\n uint256 tokenIndex": 21180, + "ACK": 21181, + "█████": 21182, + "▓▓▓": 21183, + "ix F": 21184, + ".sol\\\";\\n\\ninterface I": 21185, + "Credit": 21186, + "141 - ": 21187, + "48A03": 21188, + "28}. ": 21189, + "28 or": 21190, + "precon": 21191, + "If the signature is valid ": 21192, + ") {\\n return retval == ": 21193, + "RegistryAddress": 21194, + "{\\n // The address of the owner": 21195, + "startTimestamp;\\n // ": 21196, + "add 27 to ": 21197, + ",\\r\\n address indexed ": 21198, + "a `hash": 21199, + "EIP-2 ": 21200, + "ecrecover(). ": 21201, + "TokenOwnership {\\n // The address of the owner": 21202, + " {27, ": 21203, + "FEBAA": 21204, + "S ========== */": 21205, + "Ethereum Yellow ": 21206, + "signatures, such as ": 21207, + "revert(\\\"ERC721: transfer to non ERC721Receiver implementer": 21208, + "9236": 21209, + "upper range, ": 21210, + "ERC721.ownerOf(tokenId), to, tokenId": 21211, + "feeNumerator` cannot be greater than the fee denominator": 21212, + "/*///////////////////////////////////////////////////////////////": 21213, + "instead 27/28, ": 21214, + "en\\n * transferred to `to`.\\n * - When `from": 21215, + " == 0) {\\n return ": 21216, + "protocol fees": 21217, + ". If your library ": 21218, + "minted for `to`.\\n * - When `to` is zero, `tokenId` has been ": 21219, + "Not all ": 21220, + " in the Ethereum Yellow ": 21221, + "thus need ": 21222, + "malleable signatures, such as ": 21223, + "a new s-value": 21224, + "_balances[recipient] += amount": 21225, + "v instead 27/28, ": 21226, + "signatures as well": 21227, + "Sets `value` ": 21228, + "expired ": 21229, + ") private {\\n // To prevent a gap": 21230, + "cp.": 21231, + "Strings.toString(": 21232, + "\\n * {ERC721Enumerable}.": 21233, + "burned by `from`.\\n * - `from` and `to` are never both zero.\\n */\\n function _afterTokenTransfers(\\n address from,\\n address to,\\n uint256 startTokenId,\\n uint256 quantity\\n ": 21234, + "Out(uint amountIn": 21235, + "\\n * @author M": 21236, + "s < secp256k1n ": 21237, + "Digital ": 21238, + "https://eips.ethereum.org/EIPS/eip-2612#specification": 21239, + "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAA": 21240, + ";\\n\\n constructor() {\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and ": 21241, + "generates malleable signatures, such as ": 21242, + "revert(add(32, reason), mload(reason))\\n }\\n }\\n ": 21243, + "calculate a new s-value": 21244, + "(bytes32 _key": 21245, + "if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken": 21246, + "(https://ethereum.github.io/": 21247, + "nCheckpoints - 1].": 21248, + "paper.pdf": 21249, + "` is zero, `tokenId` has been minted for `to`.\\n * - When `to` is zero, `tokenId` has been ": 21250, + "CANONICAL_COR": 21251, + ", created from a `hash": 21252, + "27 to 28 or": 21253, + "unique. Append": 21254, + "WeightedPool": 21255, + "364141 - ": 21256, + "Remove this possibility ": 21257, + "Returns an Ethereum Signed Message, created from a `hash": 21258, + "token/ERC20/ERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.openzeppelin.com/": 21259, + ";\\n }\\n\\n /**\\n * @dev Calldata version of {": 21260, + ";\\n }": 21261, + "unique signature with an ": 21262, + "FixedPoint.ONE": 21263, + "with minimal overhead for tokenomics.\\n uint64 startTimestamp;\\n // ": 21264, + "2): v ": 21265, + "still allows signature malle": 21266, + "at `index`.\\n */\\n function ": 21267, + "ed\\n // more than ": 21268, + "1 for v instead 27/28, ": 21269, + "uint256) {\\n // Counter underflow is impossible as _burnCounter cannot be increment": 21270, + "Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as": 21271, + "tokenId < _currentIndex": 21272, + "IRED": 21273, + "biggest ": 21274, + "Shift in bits from prod1 into ": 21275, + "ability for ecrecover(). ": 21276, + "can use this function": 21277, + "over time.\\n */\\n function ": 21278, + ".\\n * It gradually moves to O(1) as tokens get transferred around ": 21279, + "malleable), return the ": 21280, + "sale price. ": 21281, + "with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAA": 21282, + "Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuard {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status;\\n\\n constructor() {\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and ": 21283, + "\"ipfs\"": 21284, + "address receiver, uint256 royaltyAmount": 21285, + ").\\n */\\ncontract ERC721A": 21286, + "0 < s < secp256k1n ": 21287, + ".\\n bool burned": 21288, + "signatures from current libraries ": 21289, + "This also deletes the contents at the last position of the array\\n delete ": 21290, + "[lastTokenId] = tokenIndex; // Update the moved token's index": 21291, + "vice versa. If your library ": 21292, + "(and not malleable), return the ": 21293, + "0/1 for v instead 27/28, ": 21294, + "v`, `r` and `s": 21295, + "paper (https://ethereum.github.io/": 21296, + "Gas spent here starts off proportional to the maximum mint batch size.\\n * It gradually moves to O(1) as tokens get transferred around ": 21297, + "6AF48A03": 21298, + "`tokenId` has been\\n * transferred to `to`.\\n * - When `from": 21299, + ", please override this function.\\n */\\n function _startTokenId": 21300, + "Whether the token has been burned.\\n bool burned": 21301, + "start time of ownership with minimal overhead for tokenomics.\\n uint64 startTimestamp;\\n // ": 21302, + "CD0364141 - ": 21303, + "v from 27 to 28 or": 21304, + "generate a unique signature with an ": 21305, + "1): 0 < s < secp256k1n ": 21306, + "s `quantity` tokens and transfers them to `to`.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `quantity` must be greater than 0": 21307, + "s1 and flip ": 21308, + "v to accept": 21309, + "yellowpaper/": 21310, + "25E8CD0364141 - ": 21311, + "and make the signature": 21312, + "), defines": 21313, + "If your library generates malleable signatures, such as ": 21314, + "EDCE6AF48A03": 21315, + "timestamp in the future": 21316, + ", and for v in ": 21317, + "BBFD25E8CD0364141 - ": 21318, + "s-value in the lower half order": 21319, + "s-values in the upper range, ": 21320, + "signatures with 0/1 for v instead 27/28, ": 21321, + "these malleable signatures as well": 21322, + "also generates signatures with 0/1 for v instead 27/28, ": 21323, + "ix F in the Ethereum Yellow ": 21324, + "28}. Most": 21325, + "If the signature is valid (and not malleable), return the ": 21326, + "add 27 to v to accept": 21327, + "EIP-2 still allows signature malle": 21328, + "TokenOwnership {\\n // The address of the owner.\\n address addr": 21329, + " {27, 28}. Most": 21330, + "paper.pdf), defines": 21331, + "` is zero, `tokenId` has been minted for `to`.\\n * - When `to` is zero, `tokenId` has been burned by `from`.\\n * - `from` and `to` are never both zero.\\n */\\n function _afterTokenTransfers(\\n address from,\\n address to,\\n uint256 startTokenId,\\n uint256 quantity\\n ": 21332, + "CANONICAL_CORI_SUBSCRIPTION": 21333, + "unique. Appendix F in the Ethereum Yellow ": 21334, + "Remove this possibility and make the signature": 21335, + "uint256) {\\n // Counter underflow is impossible as _burnCounter cannot be incremented\\n // more than ": 21336, + "Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.": 21337, + "ability for ecrecover(). Remove this possibility and make the signature": 21338, + "with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03": 21339, + "signatures from current libraries generate a unique signature with an ": 21340, + "vice versa. If your library also generates signatures with 0/1 for v instead 27/28, ": 21341, + "paper (https://ethereum.github.io/yellowpaper/": 21342, + "`tokenId` has been\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` has been minted for `to`.\\n * - When `to` is zero, `tokenId` has been burned by `from`.\\n * - `from` and `to` are never both zero.\\n */\\n function _afterTokenTransfers(\\n address from,\\n address to,\\n uint256 startTokenId,\\n uint256 quantity\\n ": 21343, + "start time of ownership with minimal overhead for tokenomics.\\n uint64 startTimestamp;\\n // Whether the token has been burned.\\n bool burned": 21344, + "s1 and flip v from 27 to 28 or": 21345, + "If your library generates malleable signatures, such as s-values in the upper range, ": 21346, + "BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or": 21347, + "If the signature is valid (and not malleable), return the signer address": 21348, + "EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature": 21349, + "unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/": 21350, + "with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or": 21351, + "signatures from current libraries generate a unique signature with an s-value in the lower half order": 21352, + "vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept": 21353, + "If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value": 21354, + "unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines": 21355, + " such": 21356, + "(WETH": 21357, + "();\\n }\\n\\n /**\\n * @notice ": 21358, + "();\\n }\\n\\n function _": 21359, + "(precision ": 21360, + ")` with ": 21361, + ",'": 21362, + ",\\r\\n ": 21363, + "-specific ": 21364, + "-formatted ": 21365, + "/9236": 21366, + "800": 21367, + "D7": 21368, + "Ell": 21369, + "Every ": 21370, + "Fi": 21371, + "MO": 21372, + "Mech": 21373, + "Please ": 21374, + "Smar": 21375, + "Source ": 21376, + "S. W": 21377, + "_, uint256 ": 21378, + "_who": 21379, + "`_data": 21380, + "cs.s": 21381, + "long ": 21382, + "mate ": 21383, + "sl": 21384, + "| ": 21385, + "~denominator + 1": 21386, + "∈ {27, 28}. Most": 21387, + "\\n returns (bool)\\n {\\n ": 21388, + "admit ": 21389, + "edits by ": 21390, + ") operation": 21391, + "ERR": 21392, + "\\\"msb": 21393, + "address of ": 21394, + "from) revert ": 21395, + "immedi": 21396, + "iptic ": 21397, + "no-": 21398, + "er 11": 21399, + "account == ": 21400, + "return min(": 21401, + ",\\n ": 21402, + "in modular ": 21403, + "es at": 21404, + ". Now that denominator is an odd number, it has an ": 21405, + "Include ": 21406, + "32 is the ": 21407, + "conve": 21408, + " to turn ": 21409, + "), following the selected rounding direction": 21410, + "that denominator * inv = 1 ": 21411, + "Allow ": 21412, + "/ denominator": 21413, + "with further ": 21414, + "symbol = ": 21415, + "Minter ": 21416, + "'s \\\"Hacker's Delight": 21417, + "ethers": 21418, + " (ECDSA": 21419, + "of the target": 21420, + "of the private key": 21421, + "number is not a ": 21422, + "safeAdd": 21423, + ";\\n } else {\\n ": 21424, + "result with one bit of precision": 21425, + "(_editionId": 21426, + "\\n // An empty struct value does not necessarily mean the token is unowned": 21427, + "in the function": 21428, + "deadline` must be a ": 21429, + "block.number ": 21430, + "twitter": 21431, + "result` is an ": 21432, + "SellToAdd": 21433, + "vious": 21434, + "number of pair": 21435, + " and mod 2^256": 21436, + " and compute ": 21437, + ");\\r\\n\\r\\n event ": 21438, + "tion with one bit of precision": 21439, + "Stake ": 21440, + "we have": 21441, + "++, _data": 21442, + "baseURI_": 21443, + ";\\n\\n assembly {\\n ": 21444, + "DevWallet": 21445, + "For our ": 21446, + "signature above": 21447, + "signature format": 21448, + "pter 11": 21449, + "counting ": 21450, + ")\\n mstore(0x": 21451, + "our partial ": 21452, + "true value is a ": 21453, + " + prod0.": 21454, + "into the expected ": 21455, + "uint64.\\n */\\n function _set": 21456, + "first guess": 21457, + "MASK_": 21458, + "message was signed by the ": 21459, + "(from, to, tokenId);\\n _afterTokenTransfers": 21460, + "2^4.": 21461, + "also under MIT licen": 21462, + "which is smaller than the ": 21463, + "\\\");\\n return owner": 21464, + "inverse = (": 21465, + "inverse modulo 2^256": 21466, + "\\n /// @param amount": 21467, + "on the signature format": 21468, + "before the ": 21469, + "Chapter 11": 21470, + "is the square root of a ": 21471, + " / twos": 21472, + "referral": 21473, + "_PERCENT": 21474, + "2^256 + prod0.": 21475, + "2^256 / twos": 21476, + "\\\"); // ": 21477, + "royalty = _": 21478, + "------------------------------------------------": 21479, + "EIP712-formatted ": 21480, + " - 1, then ": 21481, + "support ERC165 ": 21482, + "(address _account": 21483, + ").\\n * If there are multiple variables, please pack them into a ": 21484, + "over the EIP712-formatted ": 21485, + ". Thanks to Hensel's lifting lemma, this also work": 21486, + ", we get the ": 21487, + "division of two unsigned integers, ": 21488, + "string memory) {\\n if (!_exists(tokenId)) revert URIQueryForNonexistentToken();\\n\\n ": 21489, + "`.\\n */\\n function _numberBurned": 21490, + "TokenOwnership storage ": 21491, + "held ": 21492, + "number `a": 21493, + " Labs ": 21494, + "ratio * ": 21495, + " != 0) ratio": 21496, + "Uniswap Labs ": 21497, + "correct for": 21498, + "correct bit": 21499, + "inverse *= 2 - denominator * inverse; // inverse mod 2^256": 21500, + ". We know the ": 21501, + ". We don't need to compute the high bits of the result and prod1": 21502, + "Does not overflow because the ": 21503, + "can be used to verify that a ": 21504, + "that the \\\"msb": 21505, + " = (ratio * ": 21506, + "denominator with full precision": 21507, + "denominator & (": 21508, + "denominator cannot be zero ": 21509, + "balanceOf(address(this));\\n ": 21510, + "icted": 21511, + "mulDiv(x, y, ": 21512, + "uint128 result": 21513, + "paused = true": 21514, + "prod0 / denominator": 21515, + "inverse *= 2 - denominator * inverse; // inverse mod 2^8": 21516, + "type signature above": 21517, + "\\n }\\n } while (": 21518, + "sqrt(a)` with ": 21519, + "sqrt(a), following the selected rounding direction": 21520, + ",\\n // and it is initialized to ": 21521, + "pausable ": 21522, + "whenever a ": 21523, + "guarantee that the ": 21524, + "reconstruct the 512 bit result. The result is stored in two 256": 21525, + ", msg.sender, ": 21526, + ".\\n *\\n * @param seaDropImpl": 21527, + ". If twos is zero, then it becomes ": 21528, + "every iteration": 21529, + "remainder of dividing two unsigned integers, ": 21530, + "mod 2^256. Compute the ": 21531, + "mod 2^256. Now that denominator is an odd number, it has an ": 21532, + "mod 2^256 and mod 2^256": 21533, + "CAUTION: Not all ": 21534, + ".\\n // The ": 21535, + "(address to) external returns (": 21536, + "Inspired by Hen": 21537, + "Reverts if the ": 21538, + "_owners;\\n\\n // Mapping owner address to token count\\n ": 21539, + "such that we have": 21540, + ".addr = ": 21541, + "].sub(amount, \\\"ERC20: burn ": 21542, + "square root of the target": 21543, + "mulmod(x, y, denominator": 21544, + "mulmod(x, y, denominator) ": 21545, + "mulmod(x, y, not(0": 21546, + "(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n require(b <= a, errorMessage": 21547, + "at most 7 iteration": 21548, + "var-name-mixedcase": 21549, + "\\\" (most significant bit": 21550, + "\\\" (Chapter 11": 21551, + "s of a given address": 21552, + "0,\\n 0,\\n 0,\\n 0,\\n ": 21553, + "since it is the square root of a ": 21554, + "automatedMarketMakerPairs[from] ": 21555, + "x * y / ": 21556, + "result * result < ": 21557, + ") of our target ": 21558, + ". Always >= 1": 21559, + "y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0": 21560, + "red to support ERC165 ": 21561, + ") internal virtual override {\\n super._": 21562, + "prevents denominator == ": 21563, + "_balances[sender] = senderBalance - amount": 21564, + "stage in the function": 21565, + "This will give ": 21566, + "product mod 2^256 and mod 2^256": 21567, + "(https://xn--2-umb.com/21/muldiv": 21568, + "See https://cs.s": 21569, + "doubles at": 21570, + "\\n * of returning `false` on failure. This behavior is nonetheless convention": 21571, + "Newton's method ": 21572, + "prod0 := mul(x, y": 21573, + "less than 2^256. Also ": 21574, + "less than 2^256, this is the final result": 21575, + "twos such that it is ": 21576, + ";\\n\\n // Mapping owner address to address data": 21577, + "square root of a number": 21578, + "this extension's token tracking data structures": 21579, + ", // Toward negative ": 21580, + "/blob/main/src/": 21581, + "`msb(a) <= a < ": 21582, + ". Compute the product mod 2^256 and mod 2^256": 21583, + "modulo 2^256. Since the ": 21584, + "power of 2 which is smaller than the ": 21585, + "power of 2 such that we have": 21586, + "2**(k/2) <= sqrt(a) < ": 21587, + ";\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to ownership details": 21588, + "lzEndpoint": 21589, + "multiplying with the modular inverse of denominator": 21590, + "trustedRemote": 21591, + "These functions can be used to verify that a ": 21592, + ".\\n */\\n function _totalMinted(": 21593, + "ry S. W": 21594, + "ation of `sqrt(a)` with ": 21595, + "RECIPIENT": 21596, + "Script ": 21597, + "`owner`.\\n */\\n function _numberMinted": 21598, + "Collected": 21599, + "declared to support ERC165 ": 21600, + "bonding": 21601, + "uint256 currentAllowance = _allowances[_msgSender()][spender": 21602, + "138556": 21603, + "Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account": 21604, + "Curve Digital ": 21605, + "at least 1 correct bit": 21606, + "result, a / result": 21607, + "Signature Algorithm": 21608, + "us the correct result ": 21609, + "maxBatchSize": 21610, + "(a - 1) / b": 21611, + "). We thus need ": 21612, + ".sol\\\";\\nimport \\\"../../utils/Address.sol\\\";\\nimport \\\"../../": 21613, + "External interface of ": 21614, + "merkle trees admit ": 21615, + "];\\n\\n emit Transfer(owner, address(0), tokenId": 21616, + "at this stage in the function": 21617, + "minted by `owner`.\\n */\\n function _numberMinted": 21618, + "(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0": 21619, + ", Jr.": 21620, + "[WARNING]\\n * ====\\n * ": 21621, + "arren, Jr.": 21622, + "We know that the \\\"msb": 21623, + "converges quadratically ": 21624, + "al\\n * and does not conflict with the expectations of ERC20 ": 21625, + "require(denominator > prod1": 21626, + "bytes of hash": 21627, + "outcome is": 21628, + "estimation with one bit of precision": 21629, + "tackexchange.com/q/": 21630, + "credit to Remco Bloemen under MIT license ": 21631, + "length in bytes of hash": 21632, + "Use the Newton-Raphson iteration to improve the precision": 21633, + "(\\n bytes32 poolId,\\n address sender,\\n address recipient": 21634, + "At this point `result` is an ": 21635, + "` is a power of 2 such that we have": 21636, + "x * y. Compute the product mod 2^256 and mod 2^256": 21637, + "OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless convention": 21638, + "2*msb(a": 21639, + "Original credit to Remco Bloemen under MIT license ": 21640, + "ditions guarantee that the ": 21641, + "twos = denominator & (": 21642, + "remainder := mulmod(x, y, denominator": 21643, + "Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0": 21644, + "total amount of tokens minted in the contract.\\n */\\n function _totalMinted(": 21645, + "512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256": 21646, + "Make sure the result is less than 2^256. Also ": 21647, + "Invert denominator mod 2^256. Now that denominator is an odd number, it has an ": 21648, + "result = prod0 * inverse": 21649, + "let mm := mulmod(x, y, not(0": 21650, + "largest power of two divisor of denominator. Always >= 1": 21651, + "variables such that product = prod1 * 2^256 + prod0.": 21652, + "Make division exact by subtracting the remainder from [prod1 prod0].": 21653, + "perfect square, the value is ": 21654, + "four bits. That is, denominator * inv = 1 mod 2^4.": 21655, + "Factor powers of two out of denominator and compute ": 21656, + "Because the division is now exact we can divide by multiplying with the modular inverse of denominator": 21657, + "inverse by starting with a seed that is correct for": 21658, + "use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256": 21659, + "uint256. Newton's method ": 21660, + "does not decrement,\\n // and it is initialized to ": 21661, + "A helper function to ": 21662, + "delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId": 21663, + "Flip twos such that it is ": 21664, + "a == 0 ? 0 : (a - 1) / b": 21665, + "burned by or on behalf of `owner`.\\n */\\n function _numberBurned": 21666, + ").\\n */\\n function _getAux(address owner) internal view returns (uint64": 21667, + "enforced by the type signature above": 21668, + "For more information on the signature format": 21669, + "cannot exceed 2**256 - 1 (max value of uint256).\\n */\\ncontract ERC721A": 21670, + "`secp256k1` signature from ": 21671, + "÷ 2 + 1, and for v in ": 21672, + "preconditions guarantee that the ": 21673, + "Sets `value` as the allowance of `spender` ": 21674, + "2): v ∈ {27, 28}. Most": 21675, + "biggest power of 2 which is smaller than the ": 21676, + "v`, `r` and `s` must be a valid ": 21677, + ", please override this function.\\n */\\n function _startTokenId() internal view virtual returns (uint256) {\\n return 0": 21678, + "1): 0 < s < secp256k1n ÷ 2 + 1, and for v in ": 21679, + "Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721": 21680, + "(precision doubles at": 21681, + "/92363.": 21682, + "Elliptic ": 21683, + "edits by Uniswap Labs ": 21684, + "return min(result, a / result": 21685, + "in modular arithmetic, doubling the correct bits in each step": 21686, + "32 is the length in bytes of hash": 21687, + " to turn our partial ": 21688, + "that denominator * inv = 1 mod 2^256. Compute the ": 21689, + "with further edits by Uniswap Labs ": 21690, + "'s \\\"Hacker's Delight\\\" (Chapter 11": 21691, + " (ECDSA) operation": 21692, + "of the private keys of a given address": 21693, + "number is not a perfect square, the value is ": 21694, + "deadline` must be a timestamp in the future": 21695, + "SellToAddTo": 21696, + "For our first guess": 21697, + "true value is a uint128": 21698, + "into the expected uint128 result": 21699, + "uint64.\\n */\\n function _setAux(address owner, uint64 aux": 21700, + "message was signed by the holder": 21701, + "(from, to, tokenId);\\n _afterTokenTransfers(from, to, tokenId, 1": 21702, + "also under MIT license": 21703, + "inverse = (3 * denominator) ^ 2": 21704, + "inverse modulo 2^256 such": 21705, + "2^256 / twos. If twos is zero, then it becomes ": 21706, + " - 1, then use": 21707, + ").\\n * If there are multiple variables, please pack them into a uint64.\\n */\\n function _setAux(address owner, uint64 aux": 21708, + "over the EIP712-formatted function arguments.": 21709, + ", we get the biggest power of 2 which is smaller than the ": 21710, + "number `a` is a power of 2 such that we have": 21711, + " != 0) ratio = (ratio * ": 21712, + ". We know the true value is a uint128": 21713, + "Does not overflow because the denominator cannot be zero ": 21714, + "denominator with full precision, following the selected rounding direction": 21715, + "mulDiv(x, y, denominator": 21716, + "every iteration). We thus need ": 21717, + "CAUTION: Not all merkle trees admit ": 21718, + "Inspired by Henry S. W": 21719, + "at most 7 iteration to turn our partial ": 21720, + "\\\" (most significant bit) of our target ": 21721, + "since it is the square root of a uint256. Newton's method ": 21722, + "x * y / denominator with full precision, following the selected rounding direction": 21723, + "This will give us the correct result ": 21724, + "See https://cs.stackexchange.com/q/": 21725, + "less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1": 21726, + "`msb(a) <= a < 2*msb(a": 21727, + "modulo 2^256. Since the preconditions guarantee that the ": 21728, + ";\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to ownership details\\n // An empty struct value does not necessarily mean the token is unowned": 21729, + "These functions can be used to verify that a message was signed by the holder": 21730, + "ation of `sqrt(a)` with at least 1 correct bit": 21731, + "declared to support ERC165 detection": 21732, + "138556/92363.": 21733, + "Curve Digital Signature Algorithm": 21734, + "External interface of AccessControl": 21735, + "arren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11": 21736, + "We know that the \\\"msb\\\" (most significant bit) of our target ": 21737, + "converges quadratically (precision doubles at": 21738, + "estimation with one bit of precision. We know the true value is a uint128": 21739, + "Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also work": 21740, + "At this point `result` is an estimation with one bit of precision. We know the true value is a uint128": 21741, + "OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 ": 21742, + "Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv": 21743, + "twos = denominator & (~denominator + 1": 21744, + "512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use": 21745, + "Make sure the result is less than 2^256. Also prevents denominator == ": 21746, + "Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such": 21747, + "Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1": 21748, + "Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes ": 21749, + "a == 0 ? 0 : (a - 1) / b + 1": 21750, + "For more information on the signature format, see ": 21751, + "Elliptic Curve Digital Signature Algorithm": 21752, + "that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for": 21753, + "with further edits by Uniswap Labs also under MIT license": 21754, + "For our first guess, we get the biggest power of 2 which is smaller than the ": 21755, + "Does not overflow because the denominator cannot be zero at this stage in the function": 21756, + "every iteration). We thus need at most 7 iteration to turn our partial ": 21757, + "CAUTION: Not all merkle trees admit multiproof": 21758, + "Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11": 21759, + "since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at": 21760, + "This will give us the correct result modulo 2^256. Since the preconditions guarantee that the ": 21761, + "See https://cs.stackexchange.com/q/138556/92363.": 21762, + "We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have": 21763, + "Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes on": 21764, + "Elliptic Curve Digital Signature Algorithm (ECDSA) operation": 21765, + "For our first guess, we get the biggest power of 2 which is smaller than the square root of the target": 21766, + "every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision": 21767, + "This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is": 21768, + "\"pragma solidity >=": 21769, + "(new": 21770, + "1);\\n }\\n }\\n\\n /**\\n * @dev ": 21771, + "EG": 21772, + "Sa": 21773, + "[relevant ": 21774, + "];\\r\\n require(": 21775, + "_DE": 21776, + "_revert(": 21777, + "_contractBalance": 21778, + "a13": 21779, + "a, b": 21780, + "a3c": 21781, + "c7": 21782, + "dro": 21783, + "ius": 21784, + "ph": 21785, + "padding": 21786, + "pixel": 21787, + "tTotal": 21788, + "}.\\n */\\n event ": 21789, + "\\n ) external;\\n\\n function ": 21790, + " */\\n ": 21791, + "thing ": 21792, + "inline ": 21793, + "acros": 21794, + "returned by `": 21795, + "atm": 21796, + "ical ": 21797, + "to non-zero ": 21798, + "address or": 21799, + "\\n\\n /**\\n * @notice ": 21800, + "// We ": 21801, + "// Toward ": 21802, + "TokenCount": 21803, + "Revenue": 21804, + ".\\n */\\n function values(": 21805, + "not being emitted ": 21806, + "address(token": 21807, + "token contract": 21808, + "The b": 21809, + "The same ": 21810, + "This variable ": 21811, + ";\\n\\n\\t": 21812, + ";\\n\\ncontract ": 21813, + "istro": 21814, + " is allowed": 21815, + " __": 21816, + "this cannot be ": 21817, + "person ": 21818, + "oldAllowance ": 21819, + "Up, // Toward ": 21820, + "success, \\\"": 21821, + "}\\n revert OwnerQueryForNonexistentToken": 21822, + "receiving ": 21823, + "Burn ": 21824, + "__Context": 21825, + "timestamp ": 21826, + "should never be ": 21827, + ");\\r\\n require(": 21828, + "called as ": 21829, + ".\\n *\\n * Royalty ": 21830, + ";\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(": 21831, + "receiver != address(0), \\\"": 21832, + "total reflection": 21833, + "\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer": 21834, + "true if ": 21835, + "methods": 21836, + "library's ": 21837, + "subscription ": 21838, + "3608": 21839, + "_currentIndex;\\n\\n // The ": 21840, + "an address to ": 21841, + ".sol\\\";\\nimport \\\"./IERC721Receiver": 21842, + "being used ": 21843, + "159": 21844, + "1._\\n */\\n function toInt": 21845, + "send tokens ": 21846, + "Multisig": 21847, + "quantity of tokens ": 21848, + ") internal virtual { ": 21849, + "(msg.sender, address(this), ": 21850, + "999": 21851, + "nonces}": 21852, + "issuing ": 21853, + ");\\n if (rounding == Rounding.Up && ": 21854, + "shouldSwapBack": 21855, + "second ": 21856, + ".call{ value: ": 21857, + "Down, // Toward negative ": 21858, + "_operatorApprovals[owner][operator": 21859, + "if(!": 21860, + "Emits an {Approval} event": 21861, + "} else {\\n assembly {\\n ": 21862, + ";\\n }\\n return result": 21863, + "``owner``'s current nonce ": 21864, + "_beforeTokenTransfers(from, address(0), tokenId, 1": 21865, + "must use ``owner``'s current nonce ": 21866, + "upgrade ": 21867, + "guaranteed to be ": 21868, + "non-zero to non-zero ": 21869, + ") public view override returns (uint256) {\\n return ": 21870, + "protocol fee ": 21871, + ";\\n address public immutable ": 21872, + "Capital": 21873, + "ardian": 21874, + "with custom message when dividing by ": 21875, + "_Available since v3.1._\\n */\\n function toInt": 21876, + "\\\"\\\";\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\\n * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\\n * by default, can be ": 21877, + "_burnCounter;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to ownership details\\n // An empty struct value does not necessarily mean the token is unowned": 21878, + "Zero // Toward ": 21879, + "integer division of two unsigned integers, reverting ": 21880, + "integer division of two unsigned integers, reverting with custom message ": 21881, + "revert TransferToNonERC721ReceiverImplementer();": 21882, + "address owner = ERC721.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner": 21883, + "EnumerableSet.AddressSet ": 21884, + "f810": 21885, + "();\\n\\n _beforeTokenTransfers(from, to, tokenId, 1": 21886, + "\\\");\\n } else {\\n ": 21887, + "(see {nonces}": 21888, + "TransferToZeroAddress();\\n\\n _beforeTokenTransfers(from, to, tokenId, 1": 21889, + "BalanceQueryForZeroAddress();\\n return ": 21890, + "values(set._inner": 21891, + "quantity > 1.": 21892, + "string memory baseURI = _baseURI();\\n return bytes(baseURI).length != ": 21893, + ");\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\"": 21894, + "TOTAL_SUPPLY": 21895, + ");\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n ": 21896, + "(uint256 tokenId) public view virtual override returns (address) {\\n address owner = ": 21897, + "Incentive": 21898, + "\\n * ": 21899, + "Issued": 21900, + " bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt": 21901, + ") public virtual override returns (bool) {\\n address spender = _msgSender();\\n _spendAllowance(from, spender, amount);\\n _transfer(from, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, allowance(owner, spender) + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n uint256 currentAllowance = allowance(owner, spender);\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - subtractedValue);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves `amount` of tokens from `from` to `to`.\\n *\\n * This internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {\\n require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(to != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, amount);\\n\\n uint256 fromBalance = _balances[from];\\n require(fromBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n unchecked {\\n _balances[from] = fromBalance - amount": 21902, + "the signature must use ``owner``'s current nonce ": 21903, + "_transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function ": 21904, + "Return the entire set in an array\\n *\\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\\n */\\n function values(": 21905, + "result += 1;\\n }\\n return result": 21906, + "More complex ": 21907, + "TYPE_HASH": 21908, + ");\\n // Reentrancy protection": 21909, + "(\\n uint256 a,\\n uint256 b,\\n string memory errorMessage\\n ) internal pure returns (uint256) {\\n unchecked {\\n ": 21910, + "ER_BOUND": 21911, + "].add(addedValue)": 21912, + "} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721.ownerOf(tokenId), to, tokenId": 21913, + "isTxLimitExempt": 21914, + "(\\n address sender,\\n address recipient,\\n uint256 amount\\n ) external returns (bool": 21915, + "approve from non-zero to non-zero ": 21916, + "address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n ": 21917, + "2098 short ": 21918, + "receiver` cannot be the zero address.\\n * - `feeNumerator` cannot be greater than the fee denominator": 21919, + "_balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = ": 21920, + ");\\n\\n // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.\\n unchecked {\\n ": 21921, + "https://eips.ethereum.org/EIPS/eip-2612#specification[relevant ": 21922, + "if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();\\n\\n ": 21923, + "v`, `r` and `s` must be a valid `secp256k1` signature from ": 21924, + "number is not a perfect square, the value is rounded down": 21925, + "declared to support ERC165 detection.\\n */\\ninterface ": 21926, + "_currentIndex;\\n\\n // The number of tokens burned": 21927, + "} else {\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n ": 21928, + "Zero // Toward zero": 21929, + "the signature must use ``owner``'s current nonce (see {nonces}": 21930, + "approve from non-zero to non-zero allowance": 21931, + "https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP": 21932, + ")) public ": 21933, + ".\\r\\n ": 21934, + ";`": 21935, + "Cool": 21936, + "Psi": 21937, + "UD": 21938, + "WAD": 21939, + "_limit": 21940, + "_useNonce": 21941, + "`\\n *": 21942, + "boost": 21943, + "fd": 21944, + "fil": 21945, + "ging ": 21946, + "har": 21947, + "k=": 21948, + "ugs": 21949, + "\\n /**\\n * @dev ": 21950, + "rep": 21951, + "res ": 21952, + "s per ": 21953, + "onJoinPool": 21954, + "\\n unchecked {\\n return _currentIndex - ": 21955, + "throws ": 21956, + ", for ": 21957, + "t Cond": 21958, + "the user ": 21959, + "att Cond": 21960, + "tokenCount": 21961, + "arch": 21962, + "\\r\\n // ": 21963, + "to track the ": 21964, + "` with `": 21965, + "` array ": 21966, + "/** ": 21967, + ": interaction": 21968, + ": see https://github.com/ethereum/solidity/issues/": 21969, + "or counting ": 21970, + "\\n * control ": 21971, + "\\n * tokens and those that they have an allowance for, in a way that can ": 21972, + "\\n * of the private keys of a given address": 21973, + " = keccak256(\\n ": 21974, + ",\\n int256 ": 21975, + "in term": 21976, + "Inc": 21977, + "totalFees": 21978, + ";\\n _currentIndex = _startTokenId": 21979, + "recipient ": 21980, + "current(Counter storage counter": 21981, + "on (@": 21982, + ");\\n\\n _": 21983, + ";\\n\\n bytes32 public constant ": 21984, + "bytes32 constant ": 21985, + "role-based ": 21986, + "IPro": 21987, + "// Store the ": 21988, + "OnBuy": 21989, + "uint80": 21990, + "\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^": 21991, + "\\n * @dev Provides ": 21992, + ":= keccak256(0x": 21993, + ") private {\\n require(": 21994, + ". This can be used ": 21995, + "+= 1;\\n ": 21996, + "emporari": 21997, + "Buyer": 21998, + "used with ": 21999, + "_maxSupply": 22000, + "_value; // ": 22001, + "has related to ": 22002, + "128\\n ": 22003, + "(tokenId))": 22004, + "out-of-": 22005, + ", bool approvalCheck": 22006, + "previousAdmin": 22007, + "()), ": 22008, + "achieve ": 22009, + "() != ": 22010, + "Solidity v0.5.": 22011, + "library: interaction": 22012, + "default: 0": 22013, + "MAX_B": 22014, + "prevents a ": 22015, + "also apply ": 22016, + "36 ": 22017, + "s that can only be ": 22018, + "TeamFee": 22019, + "{IERC20-approve": 22020, + "\"contracts/pendle": 22021, + "\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = ": 22022, + "you want to ": 22023, + "s.\\n *\\n * These functions can be used to verify that a message was signed by the holder": 22024, + "e.g. to track the ": 22025, + "ERC721 ids, ": 22026, + "ed, though ": 22027, + ";\\r\\n address public ": 22028, + "Set storage set) private view returns (": 22029, + "counters that can only be ": 22030, + "gives the ": 22031, + "with `using Counters for Counters.Counter": 22032, + "4637": 22033, + "_ownershipOf(uint256 tokenId": 22034, + ");\\n event ": 22035, + "minter_": 22036, + "\"@openzeppelin/contracts/utils/math/Math.sol\"": 22037, + "manager": 22038, + "s of the library: interaction": 22039, + "_addMinter": 22040, + "provided, ": 22041, + "s. Each ": 22042, + "OperatorFilterer {\\n ": 22043, + "elements in a ": 22044, + "shrugs": 22045, + "(owner(), ": 22046, + "RoyaltyInfo(receiver, feeNumerator": 22047, + " = 0x00": 22048, + "block number ": 22049, + "PowerPerp": 22050, + "))\\n }\\n\\n // ": 22051, + "_init(": 22052, + "perform a ": 22053, + "ln(": 22054, + "2, this cannot be ": 22055, + "feeNumerator <= _": 22056, + ";\\n }\\n\\n uint256 ": 22057, + "counter._value ": 22058, + "from the caller's\\n * allowance.\\n *\\n * See {ERC20-_burn} and {ERC20-allowance}.\\n *\\n * Requirements:\\n *\\n * - the caller must have allowance for ": 22059, + "(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n if (b == 0) return (false, 0);\\n return (true, ": 22060, + "Gets the ": 22061, + "reserved ": 22062, + "((((((((": 22063, + "proposal to add": 22064, + "additionalPayeePrimarySales": 22065, + "stakingToken": 22066, + "(); ": 22067, + "] != 0": 22068, + "(), \\\"ERC2981: royalty fee will exceed salePrice": 22069, + "enforced, though ": 22070, + ") {\\n bytes32 computedHash = leaf": 22071, + "_checkContractOnERC721Received(from, to, tokenId, _data": 22072, + "feeDenominator(), \\\"ERC2981: royalty fee will exceed salePrice": 22073, + ", prev": 22074, + "InputHelper": 22075, + "updateSwapEnabled": 22076, + "request id": 22077, + "limit is ": 22078, + "---------------": 22079, + "Gobbler": 22080, + "zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 ": 22081, + "successful call to ": 22082, + "\\\"},{\\\"": 22083, + "feature: see https://github.com/ethereum/solidity/issues/": 22084, + ";\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address": 22085, + "MultipleAccounts": 22086, + "Deposit ": 22087, + "As of Solidity v0.5.": 22088, + "https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a ": 22089, + "ordering also apply ": 22090, + "revert TransferToNonERC721ReceiverImplementer();\\n } else {\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n ": 22091, + ".\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a ": 22092, + "_tokenRoyaltyInfo[tokenId": 22093, + ". This includes minting.\\n * And also called before burning one token": 22094, + "Solmate ": 22095, + ", \\\"!auth\\\");\\n ": 22096, + "s must be restricted ": 22097, + " of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * ": 22098, + "OpenZeppelin Contracts guidelines: functions revert\\n * instead returning `false` on failure. This behavior is nonetheless\\n * conventional and does not conflict with the expectations of ERC20\\n * applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping(address => uint256) private _balances;\\n\\n mapping(address => mapping(address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The default value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5.05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address to, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _transfer(owner, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``from``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 amount\\n ) public virtual override returns (bool) {\\n address spender = _msgSender();\\n _spendAllowance(from, spender, amount);\\n _transfer(from, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, allowance(owner, spender) + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n uint256 currentAllowance = allowance(owner, spender);\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - subtractedValue);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves `amount` of tokens from `from` to `to`.\\n *\\n * This internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {\\n require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(to != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, amount);\\n\\n uint256 fromBalance = _balances[from];\\n require(fromBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n unchecked {\\n _balances[from] = fromBalance - amount": 22099, + "rescue": 22100, + "there is a proposal to add": 22101, + "_THIS": 22102, + "about to be transferred. This includes minting.\\n * And also called before burning one token": 22103, + "token that is not ": 22104, + "ed by users of the library: interaction": 22105, + "provenance hash": 22106, + "directly accessed by users of the library: interaction": 22107, + ";\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer": 22108, + "Pct": 22109, + "currOwnershipAddr = ownership.addr": 22110, + "function. As of Solidity v0.5.": 22111, + "667c8": 22112, + ") return (false, 0);\\n return (true, c);\\n }\\n\\n /**\\n * @dev Returns the ": 22113, + ";\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert TransferToNonERC721ReceiverImplementer();\\n } else {\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n ": 22114, + "mapping, issuing ": 22115, + "\\n * @author Matt Cond": 22116, + "Include with `using Counters for Counters.Counter": 22117, + "\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (": 22118, + "Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\\n *\\n * These functions can be used to verify that a message was signed by the holder": 22119, + "The same issues ": 22120, + "This variable should never be ": 22121, + "library's function. As of Solidity v0.5.": 22122, + "or counting request id": 22123, + "\\n * tokens and those that they have an allowance for, in a way that can be\\n * re": 22124, + "on (@shrugs": 22125, + "\\n * @dev Provides counters that can only be ": 22126, + ". This can be used e.g. to track the ": 22127, + "_value; // default: 0": 22128, + "has related to transaction": 22129, + "ERC721 ids, or counting request id": 22130, + "elements in a mapping, issuing ": 22131, + "2, this cannot be enforced, though ": 22132, + "feeNumerator <= _feeDenominator(), \\\"ERC2981: royalty fee will exceed salePrice": 22133, + "feature: see https://github.com/ethereum/solidity/issues/4637": 22134, + "ordering also apply here": 22135, + "directly accessed by users of the library: interactions must be restricted ": 22136, + ";\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n ": 22137, + "\\n * @author Matt Condon (@shrugs": 22138, + "Include with `using Counters for Counters.Counter;`": 22139, + "Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\\n *\\n * These functions can be used to verify that a message was signed by the holder\\n * of the private keys of a given address": 22140, + "This variable should never be directly accessed by users of the library: interactions must be restricted ": 22141, + "library's function. As of Solidity v0.5.2, this cannot be enforced, though ": 22142, + "\\n * @dev Provides counters that can only be increment": 22143, + ". This can be used e.g. to track the number": 22144, + "elements in a mapping, issuing ERC721 ids, or counting request id": 22145, + "\\n * @author Matt Condon (@shrugs)": 22146, + "library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add": 22147, + "\"Pausable: ": 22148, + "BC": 22149, + "FL": 22150, + "IFactory": 22151, + "Marketing ": 22152, + "Pending ": 22153, + "PUT": 22154, + "Wall": 22155, + "];\\n ": 22156, + "_G": 22157, + "_frequencyInSeconds": 22158, + "ain the ": 22159, + "bc": 22160, + "\\n address public ": 22161, + "reinitializer": 22162, + "int64": 22163, + "onExitPool": 22164, + "\\n address signer = ecrecover(hash, v, r, s": 22165, + ", ERC721A": 22166, + ", i.e. ": 22167, + "\\n * section": 22168, + "oring": 22169, + ") - ": 22170, + ") and ": 22171, + "address) {\\r\\n return ": 22172, + "icsa": 22173, + "amounts.length": 22174, + "2076": 22175, + "20a3c": 22176, + "make": 22177, + "\\n * in bugs, because programmers usually assume that an overflow raises ": 22178, + ") internal {\\r\\n ": 22179, + "data[": 22180, + "} is\\n * ": 22181, + "} has related to transaction": 22182, + "newMax": 22183, + "\\n * - the signature must use ``owner``'s current nonce (see {nonces}": 22184, + "Super": 22185, + "by one. ": 22186, + "bytes32(uint256(": 22187, + "string.\\n */\\n function ": 22188, + ", uint256 required": 22189, + "token transfer to ": 22190, + ";\\n\\n if (": 22191, + "num * ": 22192, + "tokens were ": 22193, + "cc37": 22194, + "(\\n Swap": 22195, + "IN ": 22196, + "WithFallback": 22197, + ",\\n uint256 protocolSwapFeePercentage": 22198, + "\\n // these malleable signatures as well": 22199, + "\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or": 22200, + "\\n // signatures from current libraries generate a unique signature with an s-value in the lower half order": 22201, + "\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept": 22202, + "\\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines": 22203, + "\\n }\\n\\n function current(Counter storage counter": 22204, + "plet": 22205, + "buyTax": 22206, + ";\\n assembly {\\n // ": 22207, + "``\\u0027s ": 22208, + "delegation ": 22209, + "amount > 0, \\\"": 22210, + "Hash(": 22211, + "0 + ": 22212, + "PoolBalance": 22213, + "__ ": 22214, + "KKK": 22215, + " {\\n /**\\n * ": 22216, + "`account`)": 22217, + ";\\n }\\n\\n function increment": 22218, + "Stat": 22219, + "sum += ": 22220, + ").\\n *\\n * For more information on the signature format, see ": 22221, + "the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP": 22222, + ";\\n uint256 ": 22223, + "startTokenId() <= ": 22224, + "}\\n }\\n\\n /**\\n * @dev Hook that is called before ": 22225, + "sub(a, b": 22226, + "authent": 22227, + "(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n ": 22228, + ") internal virtual {\\n require(ERC721.ownerOf(tokenId) == from, \\\"ERC721: ": 22229, + "royalti": 22230, + "||||": 22231, + "s.\\n *\\n * Include with `using Counters for Counters.Counter;`": 22232, + "35a9": 22233, + "self._": 22234, + "leaf) == root": 22235, + "referred to ": 22236, + "through the ": 22237, + ") {\\n // 32 is the length in bytes of hash": 22238, + "Counter {\\n // ": 22239, + "48, ": 22240, + "Accumul": 22241, + "(\\n uint256 tokenId": 22242, + "curr < _": 22243, + "Share ": 22244, + "5d38": 22245, + "\\n uint256 _value; // default: 0": 22246, + "Compos": 22247, + ") + 1)": 22248, + ".\\n * `SafeMath` restores this intuition by reverting the transaction when ": 22249, + "decrement(Counter storage counter) internal {\\n ": 22250, + "sentinel": 22251, + "API and ": 22252, + "clusion": 22253, + "dating": 22254, + "too big": 22255, + "delegatorBalance": 22256, + "allocate": 22257, + "`.\\n *\\n * This is ": 22258, + ") internal view returns (uint256) {\\n return counter._value": 22259, + "nonce by one. ": 22260, + "92db": 22261, + "Clear": 22262, + ".\\n */\\nlibrary ECDSA": 22263, + "Counters\\n * @author Matt Condon (@shrugs)": 22264, + "restrict access to ": 22265, + ",\\n // enforced by the type signature above": 22266, + "votingP": 22267, + "for `owner`. This value ": 22268, + "spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future": 22269, + "`. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it": 22270, + "\\n // the valid range for s in ": 22271, + "consist": 22272, + "ba1a": 22273, + "periodFinish": 22274, + "94a13": 22275, + "due to the ": 22276, + ") public override returns (bool) {\\n ": 22277, + "_approve(_msgSender(), spender, currentAllowance ": 22278, + "_users": 22279, + "ages.\\n * `SafeMath` restores this intuition by reverting the transaction when ": 22280, + "fav": 22281, + "address owner = ERC721.ownerOf(tokenId);\\n return (spender == owner || ": 22282, + "signature is generated ": 22283, + "(from, address(0), tokenId);\\n _afterTokenTransfers": 22284, + "emergency": 22285, + "Move the pointer ": 22286, + "access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _transferOwnership(_msgSender());\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\"": 22287, + "swapAndLiquifyEnabled": 22288, + "{permit} increases ": 22289, + "First ": 22290, + "3e2076": 22291, + "an\\n * error, which is the standard behavior in high level programming langu": 22292, + ".\\n //\\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value": 22293, + "\\n * of elements in a mapping, issuing ERC721 ids, or counting request id": 22294, + ") internal pure returns (bytes32) {\\n bytes32 computedHash = leaf": 22295, + "signature from being used ": 22296, + ", created from a\\n * `": 22297, + "Extra data ": 22298, + "ca3e2076": 22299, + ").transfer(": 22300, + "is not active.\"": 22301, + "(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n ": 22302, + "(proof, leaf) == root": 22303, + "address that signed a hashed message (`hash`) with\\n * `signature`. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it": 22304, + ")\\n }\\n return size > 0": 22305, + "or equal to ": 22306, + "01ffc9a7 || ": 22307, + "Library for manag": 22308, + ";\\n for (uint256 i = 0; i < proof.length; i++) {\\n ": 22309, + "\\n * @title ": 22310, + "(address registrant, address registrantToCopy": 22311, + "their `": 22312, + "Alpha": 22313, + "s with added overflow\\n * checks.\\n *\\n * Arithmetic operations in Solidity wrap on overflow. This can easily result": 22314, + "(sender, recipient, amount);\\n _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, \\\"ERC20: transfer amount exceeds allowance\\\")": 22315, + "included whenever a ": 22316, + "a505d38": 22317, + "\\\");\\n\\n require(\\n _msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: ": 22318, + "Destroys `amount` tokens from the caller.\\n *\\n * See {ERC20-_burn}.\\n */\\n function burn(uint256 amount) public virtual {\\n _burn(_msgSender(), amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, deducting ": 22319, + "tokens,\\n * given ": 22320, + "to == address(0)) revert TransferToZeroAddress();\\n\\n _beforeTokenTransfers(from, to, tokenId, 1": 22321, + ", bytes32 leaf) internal pure returns (bytes32) {\\n bytes32 computedHash = leaf": 22322, + "28492db": 22323, + "\\n // this feature: see https://github.com/ethereum/solidity/issues/4637": 22324, + "`owner`\\n * over the EIP712-formatted function arguments.": 22325, + "Extension of {ERC20} that allows token holders to destroy both their own\\n * tokens and those that they have an allowance for, in a way that can be\\n * re": 22326, + "twos := add(div(sub(0, twos), twos), 1": 22327, + "2bbc": 22328, + "to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add": 22329, + "3210667c8": 22330, + "98dca3e2076": 22331, + "If the signature is valid (and not malleable), return the signer address\\n address signer = ecrecover(hash, v, r, s": 22332, + "EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines": 22333, + "Every successful call to ": 22334, + "from) revert TransferFromIncorrectOwner": 22335, + "twitter.com/": 22336, + "++, _data)) {\\n ": 22337, + "string memory) {\\n if (!_exists(tokenId)) revert URIQueryForNonexistentToken();\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length != ": 22338, + "2): v ∈ {27, 28}. Most\\n // signatures from current libraries generate a unique signature with an s-value in the lower half order": 22339, + "360894a13": 22340, + "revert TransferToNonERC721ReceiverImplementer();\\n }\\n } while (": 22341, + ");\\n\\n // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.\\n unchecked {\\n _burnCounter++": 22342, + "declared to support ERC165 detection.\\n */\\ninterface IAccessControl": 22343, + "emporarily": 22344, + "prevents a signature from being used ": 22345, + "{IERC20-approve} has related to transaction": 22346, + "MultipleAccountsFromFees": 22347, + "token that is not own": 22348, + "The same issues {IERC20-approve} has related to transaction": 22349, + "Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\\n *\\n * These functions can be used to verify that a message was signed by the holder\\n * of the private keys of a given address.\\n */\\nlibrary ECDSA": 22350, + "This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add": 22351, + ". This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request id": 22352, + "\\n * section].\\n */\\n function ": 22353, + "20a3ca505d38": 22354, + "\\n * in bugs, because programmers usually assume that an overflow raises an\\n * error, which is the standard behavior in high level programming langu": 22355, + "\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see ": 22356, + "cc3735a9": 22357, + "\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept": 22358, + "\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value": 22359, + ";\\n }\\n\\n function increment(Counter storage counter) internal {\\n ": 22360, + "the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function ": 22361, + "startTokenId() <= tokenId ": 22362, + ") {\\n // 32 is the length in bytes of hash,\\n // enforced by the type signature above": 22363, + "Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add": 22364, + "curr < _currentIndex": 22365, + "\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value": 22366, + "Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be increment": 22367, + "spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `": 22368, + "ba1a3210667c8": 22369, + "ages.\\n * `SafeMath` restores this intuition by reverting the transaction when an\\n * ": 22370, + "signature is generated for {permit": 22371, + "(from, address(0), tokenId);\\n _afterTokenTransfers(from, address(0), tokenId, 1": 22372, + ".\\n //\\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept": 22373, + "s with added overflow\\n * checks.\\n *\\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\\n * in bugs, because programmers usually assume that an overflow raises an\\n * error, which is the standard behavior in high level programming langu": 22374, + "included whenever a signature is generated for {permit": 22375, + ", bytes32 leaf) internal pure returns (bytes32) {\\n bytes32 computedHash = leaf;\\n for (uint256 i = 0; i < proof.length; i++) {\\n ": 22376, + "28492db98dca3e2076": 22377, + "\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value": 22378, + "`owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see ": 22379, + "Extension of {ERC20} that allows token holders to destroy both their own\\n * tokens and those that they have an allowance for, in a way that can be\\n * recognized off-chain (via event analysis).": 22380, + "EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\\n // the valid range for s in ": 22381, + "Every successful call to {permit} increases ": 22382, + "2): v ∈ {27, 28}. Most\\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\\n //\\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept": 22383, + "360894a13ba1a3210667c8": 22384, + "prevents a signature from being used multiple times": 22385, + ". This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`": 22386, + "20a3ca505d382bbc": 22387, + "cc3735a920a3ca505d382bbc": 22388, + "Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value": 22389, + "s with added overflow\\n * checks.\\n *\\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\\n * in bugs, because programmers usually assume that an overflow raises an\\n * error, which is the standard behavior in high level programming languages.\\n * `SafeMath` restores this intuition by reverting the transaction when an\\n * ": 22390, + "28492db98dca3e2076cc3735a920a3ca505d382bbc": 22391, + "`owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function ": 22392, + "2): v ∈ {27, 28}. Most\\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\\n //\\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\\n // these malleable signatures as well": 22393, + "360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc": 22394, + "Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n ": 22395, + "#%": 22396, + "'0": 22397, + ")\\n */\\n function ": 22398, + "){\\n ": 22399, + ")`. This value ": 22400, + ".\\\");\\n ": 22401, + ".json": 22402, + "/api/": 22403, + "PU": 22404, + "Source": 22405, + "_team": 22406, + "`2**": 22407, + "b6": 22408, + "cause": 22409, + "e8": 22410, + "eˆ": 22411, + "egr": 22412, + "k+1)": 22413, + "malici": 22414, + "v1.": 22415, + "z^": 22416, + "{revokeRole": 22417, + "\\n );\\n }\\n\\n function ": 22418, + "incenti": 22419, + ", 2": 22420, + ", f": 22421, + ", an ": 22422, + ", uint16 _": 22423, + "uint256[": 22424, + "a ? 1 : 0": 22425, + "` function ": 22426, + "Owed": 22427, + "accLog": 22428, + "matur": 22429, + "ification ": 22430, + "TransferDelay": 22431, + "balanceBefore": 22432, + "token list": 22433, + "token supply ": 22434, + "This can be re": 22435, + "num / ": 22436, + "num = (": 22437, + "atur": 22438, + ");\\n\\n address from": 22439, + "symbols needed to ": 22440, + "this role ": 22441, + "\\r\\n //": 22442, + ").\\n // ": 22443, + " ": 22444, + "eth-": 22445, + "payout ": 22446, + "bytes32 adminRole": 22447, + "bytes32 structHash": 22448, + "// Start ": 22449, + "{\\n event ": 22450, + "\"// SPDX-License-Identifier: UNLICENSED": 22451, + ",\\n address receiver": 22452, + "._\\r\\n */\\r\\n function ": 22453, + "result gives the ": 22454, + "Perm": 22455, + "Period ": 22456, + "_approve(msg.sender, ": 22457, + "overflows ": 22458, + "Min,\\r\\n address to,\\r\\n uint deadline": 22459, + "data (": 22460, + "amount > ": 22461, + "can be written ": 22462, + ") internal virtual override ": 22463, + "pointer to ": 22464, + "\\\\|": 22465, + ")\\n only": 22466, + "int256 _": 22467, + "_SALE": 22468, + "Buyback": 22469, + "grant and ": 22470, + "Consequently": 22471, + ".\\n require(": 22472, + "_tokenState": 22473, + "; // eˆ": 22474, + "string,uint256,": 22475, + "\\\");\\n require(receiver != address(0), \\\"": 22476, + "solut": 22477, + ") internal virtual {\\n delete ": 22478, + ") internal virtual {\\n _burn(tokenId, false": 22479, + "represent `value": 22480, + "Adding one ": 22481, + "Solidity 0.8": 22482, + "first 4": 22483, + "first approxim": 22484, + "\\n ) external onlyOwner {\\n ": 22485, + "ECDSA signature ": 22486, + "((k+1)": 22487, + "(a * ": 22488, + "2**((k+1)": 22489, + "to the result gives the ": 22490, + "Claimable": 22491, + "s of hex ": 22492, + "_FEE": 22493, + "_maxWalletAmount": 22494, + ".sol\\\";\\nimport \\\"../../utils/Strings": 22495, + "_BAL": 22496, + "minting and burning": 22497, + "tick ": 22498, + "case 0 ": 22499, + " + 1)`": 22500, + "uint256 result = 1 << (": 22501, + "(address registrant, bytes32 ": 22502, + "uriSuffix": 22503, + "enefici": 22504, + "DEFAULT_ADMIN_ROLE = 0x00": 22505, + "` as a hex ": 22506, + ") <= 2**(k/2": 22507, + "/2) <= 2**(k/2": 22508, + ",\\n bool approved": 22509, + ") private {\\n uint256 ": 22510, + "2, following the selected rounding direction": 22511, + ");\\n\\n /**\\n * @dev ": 22512, + "needed": 22513, + "(to, tokenId);\\n require(\\n _checkOnERC721Received": 22514, + "s is `": 22515, + "string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n _currentIndex = _startTokenId": 22516, + "log2(a) <= a < ": 22517, + "log2(a)`.": 22518, + "log2(a) >> 1": 22519, + "est way to achieve ": 22520, + ".\\n if (address(": 22521, + "ERC1967: ": 22522, + "internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer": 22523, + "\\n // @param _src": 22524, + "At the ": 22525, + ") < value ? 1 : 0": 22526, + "designed to be ": 22527, + "2**(k+1": 22528, + ") / 2)` is ": 22529, + "2dcc": 22530, + "ckpts": 22531, + "automatedMarketMakerPairs[to": 22532, + "written `2**": 22533, + "int256 constant x": 22534, + "sqrt(2**k": 22535, + "sqrt(2**(k+1": 22536, + "Override ": 22537, + "TokenApprovalRef": 22538, + "forceCall": 22539, + ", `2**(log2(a": 22540, + "token/ERC20/extensions/draft-ERC20Permit": 22541, + "exchangeRate": 22542, + "2**k` with `": 22543, + "`msb(a)=": 22544, + "interfaceId == 0x01ffc9a7 || ": 22545, + ");\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId, bool approvalCheck": 22546, + "enabled ": 22547, + ") <= sqrt(a) < sqrt(2**(k+1": 22548, + "2**(log2(a) + 1)": 22549, + "a good first approxim": 22550, + "\"The pair cannot be removed from automatedMarketMakerPairs\"": 22551, + "Optional ": 22552, + "return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n ": 22553, + "the zero address\\\");\\r\\n\\r\\n _beforeTokenTransfer": 22554, + "\"\\x19\\x01": 22555, + "according to ": 22556, + "t.me/": 22557, + ")\\n mstore(add(": 22558, + ", \\u0027UniswapV2Router": 22559, + "Interval": 22560, + "Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is ": 22561, + "; // 2ˆ": 22562, + "ByOwnerOrGovernance ": 22563, + "OUT_OF_BOUND": 22564, + "z_squared": 22565, + " ******** ********": 22566, + "uint256) {\\n if (owner == address(0)) revert BalanceQueryForZeroAddress();\\n return ": 22567, + "),\\n \\\"ERC721: transfer to non ERC721Receiver implementer\\\"\\n );\\n }\\n\\n /**\\n * @dev Mint": 22568, + ": r,": 22569, + "over time.\\n */\\n function _ownershipOf(uint256 tokenId": 22570, + "number of pairs of hex ": 22571, + "var-name-mixedcase\\n ": 22572, + "result * result < a ? 1 : 0": 22573, + "square root of a number. If the ": 22574, + "2**(k/2) <= sqrt(a) < 2**((k+1)": 22575, + ").\\n */\\n function _getAux(address owner) internal view returns (uint64) {\\n return ": 22576, + "`msb(a) <= a < 2*msb(a)`. This value ": 22577, + ";\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165": 22578, + "receiver` cannot be the zero address.\\n * - `feeNumerator` cannot be greater than the fee denominator.\\n */\\n function _set": 22579, + "v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function ": 22580, + "k=log2(a)`.": 22581, + "RoyaltyInfo(receiver, feeNumerator);\\n }\\n\\n /**\\n * @dev ": 22582, + "from the caller's\\n * allowance.\\n *\\n * See {ERC20-_burn} and {ERC20-allowance}.\\n *\\n * Requirements:\\n *\\n * - the caller must have allowance for ``accounts``'s ": 22583, + "feeNumerator <= _feeDenominator(), \\\"ERC2981: royalty fee will exceed salePrice\\\");\\n require(receiver != address(0), \\\"": 22584, + "num * z_squared": 22585, + "sum += x": 22586, + "spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function ": 22587, + "This can be rewritten `2**": 22588, + "num = (num * z_squared": 22589, + "symbols needed to represent `value": 22590, + "can be written `msb(a)=": 22591, + "Consequently, `2**(log2(a": 22592, + "; // eˆ(x": 22593, + ") internal virtual {\\n _burn(tokenId, false);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId, bool approvalCheck": 22594, + "Adding one to the result gives the ": 22595, + "uint256 result = 1 << (log2(a) >> 1": 22596, + "/2) <= 2**(k/2 + 1)`": 22597, + "log2(a) <= a < 2**(log2(a) + 1)": 22598, + ") / 2)` is a good first approxim": 22599, + "sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1": 22600, + "2**k` with `k=log2(a)`.": 22601, + "\"\\x19\\x01\"": 22602, + "Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer": 22603, + "OUT_OF_BOUNDS": 22604, + "number of pairs of hex symbols needed to represent `value": 22605, + "2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`": 22606, + "`msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=": 22607, + "This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)": 22608, + "Consequently, `2**(log2(a) / 2)` is a good first approxim": 22609, + "Adding one to the result gives the number of pairs of hex symbols needed to represent `value": 22610, + "sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))": 22611, + "`msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.": 22612, + "Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit": 22613, + "Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex ": 22614, + "(address[] calldata ": 22615, + "Hub": 22616, + "WAL": 22617, + "_trans": 22618, + "`newAdminRole": 22619, + "b65": 22620, + "effic": 22621, + "fr": 22622, + "pxCvx": 22623, + "ss": 22624, + "te ": 22625, + "╚═╝": 22626, + "\\n uint256 ": 22627, + "\\n );\\n\\n ": 22628, + "s == ": 22629, + ", string ": 22630, + "256, rounded down": 22631, + "\\n * ordering also apply here": 22632, + "tokens[": 22633, + "examples": 22634, + "ERC4626": 22635, + "ToAccount": 22636, + "ToCopy ": 22637, + "owner != ": 22638, + ".\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11": 22639, + "\\n * in the ": 22640, + ".\\n */\\n function sqrt(uint256 a": 22641, + "ump": 22642, + "what ": 22643, + "index];\\n }\\n\\n /**\\n * @dev ": 22644, + "32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^": 22645, + "and is ": 22646, + "} not being emitted ": 22647, + "process ": 22648, + "by their `": 22649, + "{\\n Down, // Toward negative ": 22650, + "currency": 22651, + "16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^": 22652, + "checks on ": 22653, + "creation ": 22654, + "cept": 22655, + "signaling ": 22656, + "0x8": 22657, + "\\n // is no longer required": 22658, + "\\n // 512 by 256 division": 22659, + "\\n // variables such that product = prod1 * 2^256 + prod0.": 22660, + "\\n // four bits. That is, denominator * inv = 1 mod 2^4.": 22661, + "\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256": 22662, + "\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1": 22663, + "\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for": 22664, + "10, rounded down": 22665, + "\\n // into the expected uint128 result": 22666, + "\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision": 22667, + "preSale": 22668, + "oldVotes": 22669, + "// SPDX-License-Identifier: MIT": 22670, + "igin ": 22671, + ";\\n return result": 22672, + "\"// SPDX-License-Identifier: MIT\\r\\n": 22673, + "constructor(address _": 22674, + ".......": 22675, + "64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^": 22676, + "\\\\:": 22677, + "Pools": 22678, + "register ": 22679, + "selves": 22680, + "_mint}": 22681, + "will be able to ": 22682, + ");\\n assembly {\\n // ": 22683, + "prod0.\\n ": 22684, + "call `": 22685, + "Reward ": 22686, + "use a ": 22687, + "sum of ": 22688, + "Initialized(": 22689, + ".\\n ///////////////////////////////////////////////": 22690, + ".\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8": 22691, + ".\\n result = prod0 * inverse": 22692, + "`.\\n *\\n * The ": 22693, + ";\\n\\n unchecked {\\n if (": 22694, + "represent a ": 22695, + "POSIT": 22696, + ") internal pure returns (uint256) {\\n if (a ": 22697, + "place": 22698, + "MinterRole": 22699, + "admin for all ": 22700, + "}.\\n *\\n * Every successful call to {permit} increases ": 22701, + "uint256(s) ": 22702, + ")\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0": 22703, + "createPair(address(this), ": 22704, + ".\\n */\\n error Mint": 22705, + ":::::": 22706, + "************************************************": 22707, + "5d24": 22708, + "Using this function ": 22709, + "role bearer": 22710, + "` is the starting ": 22711, + "hash digest": 22712, + "run ": 22713, + ".\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction": 22714, + "Issue": 22715, + "keccak256(abi.encode(_": 22716, + "\\n uint256 remainder": 22717, + "\\n uint256 prod0; // Least significant 256 bits of the product": 22718, + "\\n uint256 prod1; // Most significant 256 bits of the product": 22719, + "\\n uint256 inverse = (3 * denominator) ^ 2": 22720, + ".\\n prod1 := sub(prod1, gt(remainder, prod0": 22721, + ".\\n remainder := mulmod(x, y, denominator": 22722, + "capital": 22723, + "adminRole` as ": 22724, + ";\\n // solhint-disable-next-line no-inline-assembly": 22725, + ".\\n // See https://cs.stackexchange.com/q/138556/92363.": 22726, + ".\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is": 22727, + "revokeRole`, it is the ": 22728, + "IERC721A {\\n /**\\n * ": 22729, + "))\\n prod0 := sub(prod0, remainder": 22730, + "))\\n prod0 := mul(x, y": 22731, + ";\\n }\\n\\n /**\\n * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0": 22732, + "result = (result + a / result) >> 1;\\n return min(result, a / result": 22733, + "allocate ": 22734, + "unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use": 22735, + "].sub(subtractedValue, \\\"ERC20: decreased allowance below zero": 22736, + "``owner``'s nonce by one. ": 22737, + ").\\n */\\n function sqrt(uint256 a": 22738, + ");\\n\\n ///////////////////////////////////////////////": 22739, + "Rounding {\\n Down, // Toward negative ": 22740, + "2, rounded down": 22741, + ";\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also work": 22742, + ";\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such": 22743, + "result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result": 22744, + "\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].": 22745, + "\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator": 22746, + "\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function": 22747, + "as part of the ": 22748, + "` is set as ": 22749, + "\\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv": 22750, + ",\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at": 22751, + "> 0) {\\n result += 1;\\n }\\n return result": 22752, + "\\\");\\n require(": 22753, + ".\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n ": 22754, + ";\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/ERC20": 22755, + "must be\\n * included whenever a signature is generated for {permit": 22756, + "core/": 22757, + ");\\n }\\n }\\n\\n /**\\n * @notice Calculates ": 22758, + "\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^": 22759, + ")\\n\\n // Subtract 256 bit number from 512 bit number": 22760, + ") internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator": 22761, + "b7bf": 22762, + "address owner = ERC721.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId": 22763, + "admin role bearer": 22764, + "admin role for all ": 22765, + ".\\n if (prod1": 22766, + "solmate/src/": 22767, + "\\n assembly {\\n let mm := mulmod(x, y, not(0": 22768, + "` or `": 22769, + "0.\\n require(denominator > prod1": 22770, + "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/": 22771, + "isOperatorAllowed": 22772, + "This\\n * prevents a signature from being used multiple times": 22773, + "256 bit word": 22774, + "\"Trading is not active.\"": 22775, + ")\\n * with further edits by Uniswap Labs also under MIT license": 22776, + "ross": 22777, + "handles the ": 22778, + "RoleAdminChanged} not being emitted ": 22779, + "i = 0; i < ": 22780, + ")\\n }\\n\\n // Shift in bits from prod1 into ": 22781, + ")\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1": 22782, + " (i.e. `account`)": 22783, + ");\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n ": 22784, + ";\\n assembly {\\n size := extcodesize(account": 22785, + "/**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction": 22786, + "`, it is the role bearer": 22787, + "twos)\\n\\n // Divide [prod1 prod0] ": 22788, + "twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes on": 22789, + "by twos.\\n prod0 := div(prod0, ": 22790, + "by twos.\\n denominator := div(denominator, ": 22791, + "infinity\\n Up, // Toward ": 22792, + "infinity\\n Zero // Toward zero": 22793, + "- if using `renounceRole": 22794, + "- if using `revokeRole`, it is the ": 22795, + "\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.13;\\n\\nimport {": 22796, + "\\n */\\nabstract contract ERC20Burnable is Context": 22797, + "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\\\"": 22798, + "operatorFilterRegistry": 22799, + "e.\\n twos := add(div(sub(0, twos), twos), 1": 22800, + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n require(b > 0": 22801, + "_burn(account, amount);\\n }\\n}\\n\"": 22802, + ";\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction": 22803, + "s\\n // in modular arithmetic, doubling the correct bits in each step": 22804, + "its own admin": 22805, + "signature.length == 65": 22806, + "incorrect owner": 22807, + "IERC721Receiver(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert TransferToNonERC721ReceiverImplementer();\\n } else {\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n ": 22808, + "MinimalSwap": 22809, + "accounts with this role ": 22810, + "surrounding ": 22811, + "\\n }\\n\\n /**\\n * @dev Returns the largest of two numbers.\\n */\\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a ": 22812, + ".\\n uint256 twos = denominator & (~denominator + 1": 22813, + "_balances[sender] = _balances[sender].sub(amount, \\\"ERC20: transfer ": 22814, + "_totalSupply = _totalSupply.sub(": 22815, + "b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2;\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute.\\n return a == 0 ? 0 : (a - 1) / b + 1": 22816, + "== 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target": 22817, + ");\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ": 22818, + "\"Amount must be less than total reflection": 22819, + "notEntered ": 22820, + "s `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n ": 22821, + "despite": 22822, + ";\\n }\\n\\n // Make sure the result is less than 2^256. Also prevents denominator == ": 22823, + "uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use": 22824, + "TokenSupplyForStage": 22825, + "signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction": 22826, + "curr = tokenId;\\n\\n unchecked {\\n if (": 22827, + "Sets `adminRole` as ": 22828, + "Divide denominator by twos.\\n denominator := div(denominator, ": 22829, + "Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator": 22830, + "prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such": 22831, + "Handle non-overflow cases, 256 by 256 division.\\n if (prod1": 22832, + "roles, despite": 22833, + "inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator": 22834, + "prod0 / denominator;\\n }\\n\\n // Make sure the result is less than 2^256. Also prevents denominator == ": 22835, + "sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a": 22836, + "mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result": 22837, + "At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at": 22838, + "We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // ": 22839, + ");\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result": 22840, + "number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11": 22841, + "128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator": 22842, + "))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1": 22843, + ";\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator": 22844, + "for `owner`. This value must be\\n * included whenever a signature is generated for {permit": 22845, + "Destroys `amount` tokens from the caller.\\n *\\n * See {ERC20-_burn}.\\n */\\n function burn(uint256 amount) public virtual {\\n _burn(_msgSender(), amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, deducting from the caller's\\n * allowance.\\n *\\n * See {ERC20-_burn} and {ERC20-allowance}.\\n *\\n * Requirements:\\n *\\n * - the caller must have allowance for ``accounts``'s ": 22846, + "++, _data)) {\\n revert TransferToNonERC721ReceiverImplementer();\\n }\\n } while (": 22847, + "Extension of {ERC20} that allows token holders to destroy both their own\\n * tokens and those that they have an allowance for, in a way that can be\\n * recognized off-chain (via event analysis).\\n */\\nabstract contract ERC20Burnable is Context": 22848, + "grant and revoke ": 22849, + "est way to achieve this is ": 22850, + "`newAdminRole` is set as ": 22851, + "effici": 22852, + "32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^": 22853, + "signaling this": 22854, + "\\n // is no longer required.\\n result = prod0 * inverse": 22855, + "\\n // 512 by 256 division.\\n ///////////////////////////////////////////////": 22856, + "\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product": 22857, + "\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2": 22858, + "\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product": 22859, + "\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse": 22860, + "\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2": 22861, + "\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n ": 22862, + "\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n ": 22863, + ";\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction": 22864, + ");\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, ": 22865, + "prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such": 22866, + ".\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^": 22867, + ") internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target": 22868, + "admin for all roles, despite": 22869, + ")\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1": 22870, + "` is the starting admin for all roles, despite": 22871, + "\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator": 22872, + "\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0": 22873, + ".\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder": 22874, + ".\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function": 22875, + ".\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse": 22876, + "))\\n prod0 := mul(x, y)\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1": 22877, + ";\\n }\\n\\n /**\\n * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv": 22878, + "].sub(subtractedValue, \\\"ERC20: decreased allowance below zero\\\")": 22879, + ").\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target": 22880, + ");\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////": 22881, + "Rounding {\\n Down, // Toward negative infinity\\n Up, // Toward ": 22882, + ";\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step": 22883, + "result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates ": 22884, + "\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator": 22885, + ")\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder": 22886, + ") internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result": 22887, + "RoleAdminChanged} not being emitted signaling this": 22888, + ")\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such": 22889, + ")\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function": 22890, + "`, it is the role bearer (i.e. `account`)": 22891, + "twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, ": 22892, + "twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1": 22893, + "infinity\\n Zero // Toward zero\\n }\\n\\n /**\\n * @dev Returns the largest of two numbers.\\n */\\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a ": 22894, + "- if using `renounceRole`, it is the role bearer (i.e. `account`)": 22895, + "- if using `revokeRole`, it is the admin role bearer": 22896, + ".\\n uint256 twos = denominator & (~denominator + 1);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, ": 22897, + "b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2;\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute.\\n return a == 0 ? 0 : (a - 1) / b + 1;\\n }\\n\\n /**\\n * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv": 22898, + "\"Amount must be less than total reflections\"": 22899, + "uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product": 22900, + "signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here": 22901, + "prod0 / denominator;\\n }\\n\\n // Make sure the result is less than 2^256. Also prevents denominator == 0.\\n require(denominator > prod1": 22902, + "At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n ": 22903, + "number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target": 22904, + "128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse": 22905, + "for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ": 22906, + "Destroys `amount` tokens from the caller.\\n *\\n * See {ERC20-_burn}.\\n */\\n function burn(uint256 amount) public virtual {\\n _burn(_msgSender(), amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, deducting from the caller's\\n * allowance.\\n *\\n * See {ERC20-_burn} and {ERC20-allowance}.\\n *\\n * Requirements:\\n *\\n * - the caller must have allowance for ``accounts``'s tokens of at least\\n * `amount`.\\n */\\n function burnFrom(address account, uint256 amount) public virtual ": 22907, + "Extension of {ERC20} that allows token holders to destroy both their own\\n * tokens and those that they have an allowance for, in a way that can be\\n * recognized off-chain (via event analysis).\\n */\\nabstract contract ERC20Burnable is Context, ERC20": 22908, + "32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse": 22909, + "\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step": 22910, + ".\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse": 22911, + "\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0))\\n prod0 := mul(x, y)\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1": 22912, + ");\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator": 22913, + "Rounding {\\n Down, // Toward negative infinity\\n Up, // Toward infinity\\n Zero // Toward zero\\n }\\n\\n /**\\n * @dev Returns the largest of two numbers.\\n */\\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a ": 22914, + "result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a": 22915, + ")\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder)\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function": 22916, + ") internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the ": 22917, + ")\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step": 22918, + "twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1": 22919, + ".\\n uint256 twos = denominator & (~denominator + 1);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1": 22920, + "b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2;\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute.\\n return a == 0 ? 0 : (a - 1) / b + 1;\\n }\\n\\n /**\\n * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\\n * with further edits by Uniswap Labs also under MIT license": 22921, + "uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0))\\n prod0 := mul(x, y)\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1": 22922, + "At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a": 22923, + ".\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction": 22924, + ");\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator)\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder)\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function": 22925, + ")\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step.\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction": 22926, + ".\\n uint256 twos = denominator & (~denominator + 1);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1)\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step.\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction": 22927, + ");\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator)\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder)\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function.\\n uint256 twos = denominator & (~denominator + 1);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1)\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step.\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction": 22928, + "\"//": 22929, + ",) = ": 22930, + "0% and ": 22931, + "420": 22932, + " 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ": 23000, + "&& (": 23001, + "has permission ": 23002, + "ision": 23003, + "Set `": 23004, + ".\\n *\\n * _Available since v3.1._": 23005, + "admin\\n * ": 23006, + "adminRole = ": 23007, + "emit Transfer(address(0), to, updatedIndex": 23008, + ") revert Invalid": 23009, + "tradingAllowed": 23010, + "whenPaused ": 23011, + "r except ": 23012, + ", bytes32 adminRole": 23013, + "admin role, ": 23014, + ") external returns (bool);\\n\\n /**\\n * @notice ": 23015, + "\"contracts/interfaces/I": 23016, + "have been granted ": 23017, + ") external view returns (uint256[] memory": 23018, + ", the admin role for all ": 23019, + "weiAmount": 23020, + "address owner = ownerOf(tokenId": 23021, + "_safeMint(msg.sender, ": 23022, + "SafeCast.toUint": 23023, + "precaution": 23024, + "Contract = ": 23025, + "\\n * {RoleAdminChanged} not being emitted signaling this": 23026, + "stopLimit": 23027, + "calculation": 23028, + "role relationship": 23029, + "role has an ": 23030, + "Account is already ": 23031, + "> 0) {\\n ": 23032, + "[](tokenId": 23033, + "recoveredAddress": 23034, + "WARNING: The `": 23035, + "members;\\n ": 23036, + "optional enumeration ": 23037, + "transfer of token that is not own": 23038, + "\\n ) external returns (uint256 ": 23039, + "granted `role`.\\n *\\n * `sender` is the account that originated the contract call": 23040, + "Sale ": 23041, + "ggl": 23042, + "DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite": 23043, + ",\\n \\\"": 23044, + ")) != ": 23045, + "caches": 23046, + "replacing `": 23047, + "admin role, and only": 23048, + "(address(this), true": 23049, + ";\\n }\\n\\n": 23050, + "can call {grantRole} and {revokeRole": 23051, + "bearer except ": 23052, + "Helper ": 23053, + "By default, the admin role for all ": 23054, + "needed ": 23055, + "VRFConsumer": 23056, + "utils/Strings.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev ": 23057, + "taken to secure": 23058, + "operationsAddress": 23059, + "Split": 23060, + "mapping(address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping(uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping(address => mapping(address => bool)) private _operatorApprovals": 23061, + "(bytes32 role, bytes32 adminRole": 23062, + "s.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition": 23063, + "return c;\\n }\\n\\n /**\\n * @dev Returns the ": 23064, + "domain separator used in the ": 23065, + ",\\n address to": 23066, + "accounts that have been granted ": 23067, + "totalSupply() + ": 23068, + "admin role can call {grantRole} and {revokeRole": 23069, + "encoding of the ": 23070, + ";\\n }\\n}\"": 23071, + "solmate/blob/main/src/": 23072, + "properties": 23073, + "bytes32 indexed role, bytes32 indexed ": 23074, + "ManualNukeLP": 23075, + "\\n */\\n event RoleRevoked(": 23076, + "\\n */\\n event RoleAdminChanged(": 23077, + "\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)": 23078, + "associated admin role, and only": 23079, + "Roles are referred to ": 23080, + "\\n // - case ": 23081, + "ERC20Votes: ": 23082, + "Resolver": 23083, + "previousAdminRole, bytes32 indexed ": 23084, + ") {\\n revert(\\\"ECDSA: invalid signature length": 23085, + "Contract module that allows children to implement ": 23086, + "revoke other": 23087, + "tree\\n * ": 23088, + "newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is ": 23089, + "transfer from incorrect owner": 23090, + "Extra precaution": 23091, + "Roles can be granted ": 23092, + "check if an ": 23093, + "s can be created by ": 23094, + "} functions. Each ": 23095, + "s should be taken to secure": 23096, + ".\\n */\\n function recover(bytes32 hash, bytes memory signature": 23097, + "RoleGranted(bytes32 indexed role, address indexed account, address indexed sender": 23098, + "`.\\n *\\n * `sender` is the account that originated the contract call:\\n * ": 23099, + ");\\n\\n /**\\n * @dev Emitted when `account` is revoked `role": 23100, + "} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n */\\n function recover": 23101, + "decreasedAllowance": 23102, + "4906": 23103, + ".\\n */\\n function _safeMint(\\n address to,\\n uint256 tokenId": 23104, + "RoleData) private _roles": 23105, + "At(address registrant, uint256 index) external returns (address": 23106, + "via the {grantRole} ": 23107, + "balance query for the zero address": 23108, + ": it has permission ": 23109, + "Art Blocks ": 23110, + "dynamically via the {grantRole} ": 23111, + " is Context, ERC165, IERC721, IERC721Metadata {\\n using Address for address;\\n using Strings for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address": 23112, + "foo() public ": 23113, + "\\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner": 23114, + "Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721 is Context, ERC165, IERC721, IERC721Metadata {\\n using Address for address;\\n using Strings for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address": 23115, + "(from, to, tokenId);\\n _afterTokenTransfers(from, to, tokenId, 1);\\n }\\n\\n /**\\n * @dev ": 23116, + "role-based access": 23117, + "address that signed a hashed message (`hash`) with\\n * `signature`. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it.\\n */\\n function recover(bytes32 hash, bytes memory signature": 23118, + "{revokeRole} functions. Each ": 23119, + ", an admin role": 23120, + "will be able to grant or ": 23121, + "its own admin: it has permission ": 23122, + "accounts with this role will be able to grant or ": 23123, + "curr = tokenId;\\n\\n unchecked {\\n if (_startTokenId() <= ": 23124, + "grant and revoke this role. ": 23125, + "- if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)": 23126, + "JavaScript ": 23127, + "` identifier. These ": 23128, + ". More complex role relationship": 23129, + "and revoked dynamically via the {grantRole} ": 23130, + "external API and be ": 23131, + "that only accounts with this role will be able to grant or ": 23132, + "` is also its own admin: it has permission ": 23133, + ".\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(": 23134, + "adminRole = adminRole": 23135, + "admin role, replacing `": 23136, + "\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(": 23137, + "role has an associated admin role, and only": 23138, + "bearer except when using {": 23139, + "By default, the admin role for all roles is `": 23140, + "mapping(address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping(uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping(address => mapping(address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection": 23141, + "accounts that have been granted it": 23142, + "bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed ": 23143, + "Roles are referred to by their `": 23144, + "Contract module that allows children to implement role-based access": 23145, + "newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call": 23146, + "Extra precautions should be taken to secure": 23147, + "Roles can be granted and revoked dynamically via the {grantRole} ": 23148, + "s can be created by using": 23149, + "`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)": 23150, + ");\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)": 23151, + "{revokeRole} functions. Each role has an associated admin role, and only": 23152, + "grant and revoke this role. Extra precautions should be taken to secure": 23153, + ". More complex role relationships can be created by using": 23154, + "that only accounts with this role will be able to grant or revoke other": 23155, + "admin role, replacing `previousAdminRole": 23156, + ");\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(": 23157, + " : ": 23158, + ".,": 23159, + ".2": 23160, + ".div(": 23161, + ".ownerOf(tokenId": 23162, + "2E": 23163, + "2a": 23164, + "30 ": 23165, + "40 ": 23166, + "5C": 23167, + "BN": 23168, + "Calc": 23169, + "Day ": 23170, + "EP": 23171, + "Has": 23172, + "Use": 23173, + "X ": 23174, + "[Web": 23175, + "_MAX": 23176, + "_fallback": 23177, + "`\\n * - `": 23178, + "b9": 23179, + "b) private pure returns (": 23180, + "sert": 23181, + "similar": 23182, + "ylist": 23183, + "}.\\n * ": 23184, + "}:\\n *\\n * ": 23185, + "s by ": 23186, + "en.": 23187, + "\\n _": 23188, + "uint) {\\n ": 23189, + "ed-": 23190, + "\\n * bearer except when using {": 23191, + "the gas cost of ": 23192, + "endpoint": 23193, + "iterations": 23194, + "\\n return ": 23195, + "ed Data": 23196, + "is effectively ": 23197, + "to == ": 23198, + "` modifier ": 23199, + "` hash digest": 23200, + "uint256 value = ": 23201, + "d || ": 23202, + "image": 23203, + "mation": 23204, + "agment": 23205, + "ERC20Mintable": 23206, + "an event": 23207, + "\\n * ```\\n *\\n * ": 23208, + "\\n * accounts that have ": 23209, + "\\n * accounts that have been granted it": 23210, + ".\\n */\\n function nonces(address owner) external view returns (uint256": 23211, + "in Solidity ": 23212, + "7233": 23213, + "public constant": 23214, + "--;\\n ": 23215, + "} {\\n ": 23216, + "), amount": 23217, + "...\\n * ": 23218, + "bytes32` identifier. These ": 23219, + "value > 0, \\\"": 23220, + "IERC20.sol\"": 23221, + ";\\n\\n bool public ": 23222, + "e {grantRole": 23223, + "this occur": 23224, + "when setting": 23225, + "pure override returns (": 23226, + "ContractMetadata": 23227, + "roles for the ": 23228, + "divUp": 23229, + "10), ": 23230, + ") internal pure returns (uint256) {\\n return ": 23231, + "RoleData {\\n ": 23232, + "Protection": 23233, + "`, as ": 23234, + "data The ": 23235, + "router ": 23236, + "will be true": 23237, + "100%": 23238, + "::delegateBySig": 23239, + "RewardFee": 23240, + "_burnFrom": 23241, + " and `": 23242, + "\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite": 23243, + "1 byte ": 23244, + "v3.3.0": 23245, + "given registrant": 23246, + "User ": 23247, + "IERC721Receiver.onERC721Received.selector": 23248, + "STANT": 23249, + "call to `": 23250, + "Typed Data": 23251, + "way is effectively ": 23252, + "factory()).": 23253, + ", it will ": 23254, + "(bytes32 a": 23255, + "(bytes32 domainSeparator": 23256, + "signer, ": 23257, + ", bytes32 structHash": 23258, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _transferOwnership(_msgSender());\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\"": 23259, + ") external returns (bool);\\n\\n function ": 23260, + ") internal {\\n if (": 23261, + "\\n * @param account ": 23262, + "}, this function ": 23263, + ", but we ": 23264, + "ANC": 23265, + "block.number, \\\"": 23266, + "filtered by ": 23267, + "to\\n * grant and revoke this role. Extra precautions should be taken to secure": 23268, + "Role(bytes32 role, address account) internal virtual {\\n _": 23269, + " - 1]": 23270, + "AccountSnapshot": 23271, + "Complet": 23272, + "\\n * ...\\n * ": 23273, + "\\\");\\r\\n return ": 23274, + "whenNotPaused(": 23275, + "license": 23276, + "imposed by {": 23277, + "should be exposed": 23278, + "initial roles for the ": 23279, + "[from][msg.sender": 23280, + "\\n\\t * @param _": 23281, + "),\\n // ": 23282, + "3c0e": 23283, + "string(\\n abi.encodePacked(": 23284, + "domainSeparator` and a `": 23285, + "(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` ": 23286, + "structHash`. This ": 23287, + "DEFAULT_ADMIN_ROLE`, which ": 23288, + "DEFAULT_ADMIN_ROLE` is also its own admin: it has permission ": 23289, + "and\\n * {revokeRole} functions. Each role has an associated admin role, and only": 23290, + "All three ": 23291, + "built in ": 23292, + "}.\\n *\\n * WARNING: The `": 23293, + "}.\\n *\\n * By default, the admin role for all roles is `": 23294, + "_msgSender(), \\\"AccessControl: can only renounce roles for self": 23295, + "function call, use {": 23296, + "can be used to represent a ": 23297, + "Requirements:\\r\\n *\\r\\n * - ": 23298, + "952": 23299, + ") = _get": 23300, + "return\\n interfaceId == 0x01ffc9a7 || ": 23301, + "constructor when setting": 23302, + "still do the ": 23303, + ", since this occur": 23304, + ", msg.sender));": 23305, + "00000000000000000000000000000000000000000000000000000000": 23306, + "governance ": 23307, + "bytes32 public constant MY_ROLE": 23308, + "}\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} ": 23309, + ");\\n }\\n\\n /**\\n * @dev ": 23310, + "means\\n * that only accounts with this role will be able to grant or revoke other": 23311, + "++i;\\n }\\n ": 23312, + "core/contracts/interfaces/": 23313, + "using `public constant": 23314, + "sorted in ": 23315, + " = keccak256(\\\"MY_ROLE": 23316, + ";\\n }\\n\\n /**\\n * @dev ": 23317, + "********************************************************************************": 23318, + "[`eth_signTypedData": 23319, + "goes ": 23320, + "https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData": 23321, + ".sol\\\";\\nimport \\\"./extensions/IERC721Metadata": 23322, + "ridg": 23323, + "_ownerships[startTokenId": 23324, + "MY_ROLE, msg.sender));": 23325, + "✓✓✓✓✓✓✓✓": 23326, + "\\r\\n\\t\\tu": 23327, + "circumventing the ": 23328, + "\\n * - ": 23329, + "home/": 23330, + "token/ERC721/ERC721.sol\"": 23331, + "tokenIdsMaxLength = ": 23332, + "as well as ": 23333, + "ToAddLiquidityWith": 23334, + ". Note that unlik": 23335, + "();\\n }\\n\\n _beforeTokenTransfers(from, address(0), tokenId, 1": 23336, + "must not be paused.\\n */\\n function _": 23337, + "_approve(sender, _msgSender(), currentAllowance - amount": 23338, + "Roles can be used to represent a ": 23339, + "unique. The b": 23340, + "system imposed by {": 23341, + "cause ": 23342, + "with the registry and ": 23343, + "RoleRevoked(role, account, _msgSender()": 23344, + "RoleGranted(role, account, _msgSender()": 23345, + "_setupRole}.\\n */\\n event ": 23346, + "bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev ": 23347, + "the same length": 23348, + " {\\n enum Rounding {\\n Down, // Toward negative infinity\\n Up, // Toward infinity\\n Zero // Toward zero\\n }\\n\\n /**\\n * @dev Returns the largest of two numbers.\\n */\\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a ": 23349, + "toTypedDataHash(bytes32 domainSeparator": 23350, + "_operatorApprovals[_msgSender()": 23351, + "This function should only be called from the constructor when setting": 23352, + "\\n ) internal pure returns (bool) {\\n return processProof": 23353, + "Registers an address ": 23354, + "filtered operators and codeHashes": 23355, + "32-byte word ": 23356, + "up the initial roles for the ": 23357, + "\\n ) external payable returns (": 23358, + ")\\n external\\n payable\\n returns (": 23359, + "vrfCoordinator": 23360, + "set of permissions. To ": 23361, + "// File: @openzeppelin/contracts/": 23362, + "Write the ": 23363, + ". However, since this occur": 23364, + "/// @solidity memory-safe-assembly\\n assembly {\\n // ": 23365, + "2273": 23366, + "\\n * roles. More complex role relationships can be created by using": 23367, + "require(hasRole(MY_ROLE, msg.sender));": 23368, + "Returns an Ethereum Signed Typed Data": 23369, + ",\\n bytes32 root,\\n bytes32 leaf\\n ) internal pure returns (bool) {\\n return processProof": 23370, + ");\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(\\n address to,\\n uint256 tokenId": 23371, + "in any other way is effectively ": 23372, + "Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuard {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status;\\n\\n constructor() {\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and making it call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant(": 23373, + "account == _msgSender(), \\\"AccessControl: can only renounce roles for self": 23374, + ".sol\\\";\\nimport \\\"../../utils/Address.sol\\\";\\nimport \\\"../../utils/Context": 23375, + "A helper function to check if an ": 23376, + "}\\n revert OwnerQueryForNonexistentToken(": 23377, + "`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite": 23378, + "\\n * control mechanisms": 23379, + ", prevOwnership": 23380, + "(from, address(0), tokenId);\\n _afterTokenTransfers(from, address(0), tokenId, 1);\\n\\n // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.\\n unchecked {\\n _burnCounter++": 23381, + "\\n * in the external API and be ": 23382, + "Using this function in any other way is effectively ": 23383, + "``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times": 23384, + ";\\n assembly {\\n size := extcodesize(account)\\n }\\n return size > 0": 23385, + "for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times": 23386, + "(bytes32 role, bytes32 adminRole) internal virtual {\\n ": 23387, + "admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `": 23388, + "RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(": 23389, + ", an admin role\\n * bearer except when using {": 23390, + "\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed ": 23391, + "Roles are referred to by their `bytes32` identifier. These ": 23392, + "Contract module that allows children to implement role-based access\\n * control mechanisms": 23393, + "newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {": 23394, + "admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite": 23395, + "e {grantRole}, this function ": 23396, + "filtered by a given address or its subscription.\\n */\\n function ": 23397, + "to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it": 23398, + "\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} ": 23399, + "domainSeparator` and a `structHash`. This ": 23400, + "and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have ": 23401, + "built in overflow ": 23402, + "function call, use {hasRole": 23403, + "still do the swap ": 23404, + "bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE": 23405, + "means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using": 23406, + "using `public constant` hash digest": 23407, + ". Note that unlike {grantRole}, this function ": 23408, + "Roles can be used to represent a set of permissions. To ": 23409, + "unique. The best way to achieve this is ": 23410, + "system imposed by {AccessControl": 23411, + "_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(": 23412, + "toTypedDataHash(bytes32 domainSeparator, bytes32 structHash": 23413, + "up the initial roles for the system": 23414, + "Using this function in any other way is effectively circumventing the ": 23415, + "\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {": 23416, + "Roles are referred to by their `bytes32` identifier. These should be exposed": 23417, + "admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {": 23418, + "\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have ": 23419, + "domainSeparator` and a `structHash`. This produces hash ": 23420, + "bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");": 23421, + "means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {": 23422, + "Roles can be used to represent a set of permissions. To restrict access to ": 23423, + "_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev ": 23424, + "(computedHash, ": 23425, + "-sign": 23426, + "-eth-": 23427, + ".set": 23428, + "1C": 23429, + "1%\"": 23430, + "BACK": 23431, + "GEN": 23432, + "LN": 23433, + "Ph": 23434, + "WA": 23435, + "Work": 23436, + "[ethers": 23437, + "b2dcc": 23438, + "cat": 23439, + "js]": 23440, + "les": 23441, + "scop": 23442, + "s without ": 23443, + "ad804": 23444, + "\\n * up the initial roles for the system": 23445, + "itt": 23446, + "to whom": 23447, + "ToRedeem": 23448, + "TokenID": 23449, + "ele": 23450, + "ipedia": 23451, + "ages ": 23452, + "accounts.html#": 23453, + "calldatacopy": 23454, + "an authorized ": 23455, + ".\\n *\\n * See ": 23456, + ".\\n *\\n * Using this function in any other way is effectively circumventing the ": 23457, + "return buffer": 23458, + " = 0) {\\r\\n ": 23500, + "performing ": 23501, + "(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`": 23502, + "assembly { ": 23503, + "signer/#": 23504, + ", bytes32 b) private pure returns (": 23505, + "let length": 23506, + "takeFee = ": 23507, + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuard {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status;\\n\\n constructor() {\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and making it call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant(": 23508, + "CONSTANT": 23509, + "} event.\\n */\\n function _setRoleAdmin": 23510, + "5d85": 23511, + ") >> 255": 23512, + "Withdrawal": 23513, + "Data memory ": 23514, + "startTimestamp = = ": 23565, + "There is ": 23566, + " of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd": 23567, + " of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub": 23568, + "burned = false": 23569, + "Farming": 23570, + "bytes32) {\\n return _roles[role].adminRole": 23571, + "Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function ": 23572, + "charge": 23573, + "CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub": 23574, + "RoleAdminChanged} event.\\n */\\n function _setRoleAdmin": 23575, + "docs.ethers.io/v5": 23576, + "\\n mapping(uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n ": 23577, + "BASE_": 23578, + "c927e": 23579, + "addr =
>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = _HEX_SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n}\\n\"": 23628, + "domain separator used in the encoding of the ": 23629, + "RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00": 23630, + "foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));": 23631, + "en.wikipedia": 23632, + "\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to ": 23633, + "7233c927e": 23634, + "(bytes32 a, bytes32 b) private pure returns (": 23635, + "Role(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ": 23636, + "DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {": 23637, + "DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it": 23638, + "2273b7bfad804": 23639, + "account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function ": 23640, + "\\n * in the external API and be unique. The best way to achieve this is ": 23641, + "admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {": 23642, + "Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is ": 23643, + "bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to ": 23644, + "LN_36_": 23645, + "\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the ": 23646, + "accounts.html#sign[Web": 23647, + "3.4/web3-eth-": 23648, + "signature generation:": 23649, + ");\\n _roles[role].adminRole = adminRole": 23650, + "temp := div(temp, 10": 23651, + "defined by {EIP712": 23652, + "5d85a4": 23653, + "3ca82273b7bfad804": 23654, + "readthedocs.io/en/v1.3.4/web3-eth-": 23655, + "703c0e500b65": 23656, + "perform any\\n * checks on the calling account.\\n *\\n * ": 23657, + "a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub": 23658, + "7db2dcc703c0e500b65": 23659, + "Signer-signMessage[ethers": 23660, + "multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul": 23661, + "by\\n * using `public constant` hash digests:\\n *\\n * ": 23662, + "_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it": 23663, + "bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev ": 23664, + "docs.ethers.io/v5/api/signer/#": 23665, + "\\n mapping(uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping(address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping(uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping(address => mapping(address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection": 23666, + ".\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n ": 23667, + ", add(48, mod(temp, 10))": 23668, + "web3js.readthedocs.io/en/v1.3.4/web3-eth-": 23669, + "a\\n * function call, use {hasRole}:\\n *\\n * ": 23670, + "On the first call to nonReentrant, _notEntered will be true": 23671, + "Documentation for signature generation:": 23672, + "[WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the ": 23673, + "5d2460186f7233c927e": 23674, + "admin\\n * system imposed by {AccessControl}.\\n * ": 23675, + "domain separator used in the encoding of the signature ": 23676, + "foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have ": 23677, + "en.wikipedia.org/wiki/": 23678, + "admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it": 23679, + "Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ": 23680, + "bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ": 23681, + "accounts.html#sign[Web3.js]": 23682, + "3ca82273b7bfad8045d85a4": 23683, + "7db2dcc703c0e500b653ca82273b7bfad8045d85a4": 23684, + "docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers": 23685, + "web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]": 23686, + "[WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ": 23687, + "5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a4": 23688, + ",\\n ": 23689, + "-2098 short ": 23690, + "1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base ": 23691, + "2 > 0) {\\n value >>= ": 23692, + "378": 23693, + "4 > 0) {\\n value >>= ": 23694, + "523": 23695, + "8 > 0) {\\n value >>= ": 23696, + "8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base ": 23697, + "A8": 23698, + "FOR": 23699, + "Ter": 23700, + "]++": 23701, + "_not": 23702, + "_HEX_SYMBOLS": 23703, + "bound ": 23704, + "cd || ": 23705, + "gam": 23706, + "goo": 23707, + "hour": 23708, + "held": 23709, + "ion ": 23710, + "window": 23711, + "╣╣": 23712, + "ream": 23713, + "thres": 23714, + "adult": 23715, + "252": 23716, + "uint256);\\n\\n function ": 23717, + "exi": 23718, + "ed on ": 23719, + "d = ": 23720, + "@dev ": 23721, + "public\\r\\n ": 23722, + "ables": 23723, + "s (such as ": 23724, + ".\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex ": 23725, + "FeeBps": 23726, + "overall": 23727, + ". The": 23728, + ". All ": 23729, + "\\tfunction ": 23730, + " to a ": 23731, + "cket ": 23732, + "\\r\\n );\\r\\n\\r\\n ": 23733, + ") external view virtual ": 23734, + "IERC20(_": 23735, + "> b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2;\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute.\\n return a == 0 ? 0 : (a - 1) / b + 1;\\n }\\n\\n /**\\n * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\\n * with further edits by Uniswap Labs also under MIT license": 23736, + "}\\n}\"": 23737, + "\\n // the ": 23738, + "Record": 23739, + "/// @param ": 23740, + "import \\\"../": 23741, + "` to be ": 23742, + "amount The ": 23743, + "ATCH": 23744, + "id == ": 23745, + "userReward": 23746, + "\"@openzeppelin/contracts/access/AccessControl": 23747, + "\"@openzeppelin/contracts/token/ERC721/ERC721.sol\"": 23748, + "non-reverting ": 23749, + ".\\n uint256 result = 1 << (log2(a) >> 1": 23750, + "indow ": 23751, + "128;\\n }\\n if (value >> ": 23752, + "we already ": 23753, + "buffer, ": 23754, + ");\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature ": 23755, + "mismatch": 23756, + "\\r\\n */\\r\\n function ": 23757, + ") / 1000": 23758, + "0.8.4": 23759, + ");\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a": 23760, + "uint32 _": 23761, + "s.\\n *\\n * The ": 23762, + "[EIP-2098 short ": 23763, + "optimized ": 23764, + ";\\n }\\n if (value >> 32 > 0) {\\n value >>= ": 23765, + ";\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += ": 23766, + "management": 23767, + ".sol';\\n\\n/**\\n * @dev Interface of ": 23768, + "maxTransactionAmount ": 23769, + ": invalid multiproof": 23770, + "log2(value);\\n return result + (rounding == Rounding.Up && ": 23771, + ".\\n // The ": 23772, + "on behalf of ": 23773, + "blacklists": 23774, + "_balances[from] -= 1;\\n ": 23775, + "randomizer": 23776, + ", of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex ": 23777, + "paused state": 23778, + "MerkleProof: invalid multiproof": 23779, + "sqrt(a);\\n return result + (rounding == Rounding.Up && ": 23780, + "Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on ": 23781, + "_packedAddressData[owner": 23782, + "log256(value);\\n return result + (rounding == Rounding.Up && ": 23783, + "log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = ": 23784, + "log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += ": 23785, + "log10(value);\\n return result + (rounding == Rounding.Up && ": 23786, + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = ": 23787, + ")\\n external\\n view\\n returns (\\n ": 23788, + "InitialSupply": 23789, + "r` and `vs` short-signature fields separately": 23790, + "(bytes32 hash) internal pure returns (bytes32": 23791, + ">= amount, \\\"ERC20: transfer amount exceeds allowance": 23792, + ") external;\\n\\n /**\\n * @dev Returns the current nonce ": 23793, + "} that receives the `r` and `vs` short-signature fields separately": 23794, + ", Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && ": 23795, + "AILED": 23796, + "keep the ": 23797, + "PRICE_PRECISION": 23798, + "decimals = decimals_": 23799, + ", address[] calldata path) external view returns (": 23800, + "numTokensSellToAddTo": 23801, + "32;\\n result += 4;\\n }\\n if (value >> ": 23802, + "16;\\n result += 16": 23803, + "64;\\n result += 8;\\n }\\n if (value >> ": 23804, + "(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && ": 23805, + "(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && ": 23806, + ");\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down": 23807, + "(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= ": 23808, + "result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction": 23809, + "}\\n\\n return result": 23810, + "\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)": 23811, + "\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit": 23812, + "s[0]": 23813, + ".\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // ": 23814, + ") public view virtual override returns (uint256) {\\n require(index < ": 23815, + "BalancerErrors": 23816, + "Destin": 23817, + ",\\n bytes memory userData\\n ": 23818, + "string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ": 23819, + "interfaceId == 0x80ac58": 23820, + "uint amountToken, uint amountETH, uint liquidity": 23821, + "2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base ": 23822, + "2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base ": 23823, + "4;\\n result += 4": 23824, + "4;\\n result += 4;\\n }\\n if (value >> ": 23825, + "8;\\n result += 8": 23826, + "8;\\n result += 8;\\n }\\n if (value >> ": 23827, + "32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> ": 23828, + "\\n * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers": 23829, + "\\n * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]": 23830, + "16;\\n }\\n if (value >> 64 > 0) {\\n value >>= ": 23831, + "16;\\n }\\n if (value >> 8 > 0) {\\n value >>= ": 23832, + "64 > 0) {\\n value >>= 64;\\n result += 64": 23833, + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += ": 23834, + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && ": 23835, + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && ": 23836, + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= ": 23837, + "32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += ": 23838, + "result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down": 23839, + "result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down": 23840, + "`\\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`": 23841, + "`\\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))": 23842, + "16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base ": 23843, + "InternalBalance": 23844, + ".\\n mstore(0x40, ": 23845, + "keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n32\\\", ": 23846, + "DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\"": 23847, + "2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base ": 23848, + "_SWAP_FEE_PERCENT": 23849, + "https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short ": 23850, + "1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down": 23851, + "_approve(address(this), address(uniswapV2Router), tokenAmount": 23852, + "custom:oz": 23853, + ");\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n ": 23854, + "_buyerMap": 23855, + "1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction": 23856, + "tokenId < _currentIndex && ": 23857, + "string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += ": 23858, + "(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n ": 23859, + "2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && ": 23860, + "result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down": 23861, + "square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target": 23862, + "`msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)": 23863, + "MinimalSwapInfo": 23864, + "`newAdminRole` is set as ``role``'s ": 23865, + "signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function ": 23866, + ") internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target": 23867, + "of all the tokens ": 23868, + ".\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature ": 23869, + "for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature ": 23870, + "defined by {EIP712}.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function ": 23871, + "2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base ": 23872, + "4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> ": 23873, + "non-reverting call": 23874, + ".\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a": 23875, + "128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64": 23876, + ";\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += ": 23877, + ", of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += ": 23878, + "log256(value);\\n return result + (rounding == Rounding.Up && 1 << (": 23879, + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log256(value);\\n return result + (rounding == Rounding.Up && 1 << (": 23880, + ") external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature ": 23881, + ", Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down": 23882, + "64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> ": 23883, + "\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a": 23884, + ".\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)": 23885, + "interfaceId == 0x80ac58cd || ": 23886, + "8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> ": 23887, + "16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> ": 23888, + "16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> ": 23889, + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64": 23890, + "result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += ": 23891, + "`\\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a": 23892, + "`\\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a": 23893, + "keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n32\\\", hash": 23894, + "https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures": 23895, + "1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= ": 23896, + "1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && ": 23897, + "2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= ": 23898, + ") internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)": 23899, + "2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= ": 23900, + ";\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> ": 23901, + ", Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64": 23902, + "16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base ": 23903, + "result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base ": 23904, + "`\\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64": 23905, + ") internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64": 23906, + ";\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> 2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= ": 23907, + ") internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> 2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= ": 23908, + " + _": 23909, + "');\\n ": 23910, + "-token": 23911, + "=0": 23912, + "Dead": 23913, + "DRA": 23914, + "Egg": 23915, + "Futu": 23916, + "Hdrn": 23917, + "Master": 23918, + "SYMBOLS": 23919, + "TC": 23920, + "_num": 23921, + "a3": 23922, + "bd": 23923, + "bal": 23924, + "ces ": 23925, + "uq": 23926, + "xf": 23927, + "s it": 23928, + "\\n );\\n _": 23929, + ", mul(": 23930, + "ed/": 23931, + "2500": 23932, + "\\n * quantity - the amount to be transferred": 23933, + "isRegistered": 23934, + "\\\") {\\n ": 23935, + "ERC1363": 23936, + ".\\n *\\n * startTokenId - the first token id to be transferred": 23937, + "record": 23938, + "InMax": 23939, + "indexOut": 23940, + "} 1 {": 23941, + "totalAmount": 23942, + "import": 23943, + "private _decimals": 23944, + "with\\n // ": 23945, + "that all ": 23946, + "that doesn't ": 23947, + "string public constant ": 23948, + ") public view returns(": 23949, + "burnAmount": 23950, + " is ERC20, ": 23951, + "ards to ": 23952, + "Mint(": 23953, + "pausers": 23954, + " * 1e18": 23955, + "bytes32 merkleRoot": 23956, + "will have ": 23957, + "WithFee": 23958, + "balanceOf} to enumerate ": 23959, + "mod(value, ": 23960, + "div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return ": 23961, + "div(a, b": 23962, + "blockForPenalty": 23963, + "string memory buffer = new ": 23964, + " break": 23965, + "] = _SYMBOLS": 23966, + "{\\n struct ": 23967, + "safe32": 23968, + ",\\n address owner": 23969, + "s, bool ": 23970, + "Charg": 23971, + "using SafeERC20 for IERC20": 23972, + "+= (fees * ": 23973, + "twards to ": 23974, + "\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function ": 23975, + "Administr": 23976, + "Implied": 23977, + "firmation": 23978, + "back to the ": 23979, + "burned` ": 23980, + ".\\n uint256 internal ": 23981, + "\\n *\\n * Calling conditions:\\n *\\n * - ": 23982, + "signature expired": 23983, + "Allows the ": 23984, + "delegated ": 23985, + ")\\n public": 23986, + ".sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.": 23987, + "if (value == 0) ": 23988, + "Solidity code": 23989, + "owned by `owner` ": 23990, + "() external view returns(": 23991, + "ECDSA.sol\"": 23992, + ";\\n emit OwnershipTransferred(address(0), msgSender": 23993, + "LastX128": 23994, + "712.\\n *\\n * See {recover}.\\n */\\n function ": 23995, + "to the one signed with the\\n * ": 23996, + "lib/Constant": 23997, + "let m": 23998, + "currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance": 23999, + ".sol\\\";\\n\\n// ": 24000, + "supportsInterface(bytes4 interfaceId)\\n public\\n view\\n virtual\\n override(": 24001, + "interfaceId == 0x5b5e139f": 24002, + "(address(this).": 24003, + "ChainId ": 24004, + "```\\n * function ": 24005, + "Cannot set ": 24006, + "Sheep": 24007, + "stop`)": 24008, + "INITIAL_DOMAIN_SEPARATOR": 24009, + "INITIAL_CHAIN_ID": 24010, + "Withdraw ": 24011, + "term = ((": 24012, + "term * x": 24013, + "swap fees": 24014, + "- the source ": 24015, + ");\\n }\\n }\\n }\\n\\n function ": 24016, + "shouldTakeFee": 24017, + "\\n override(": 24018, + "string(length": 24019, + "do nothing": 24020, + ";\\n\\n function ": 24021, + "(address(this), subscriptionOrRegistrantToCopy": 24022, + "add(32, length": 24023, + "));\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Typed Data": 24024, + "VALU": 24025, + "\\n return keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n32\\\", hash": 24026, + "VRG": 24027, + "methods.": 24028, + "balanceOf(address(this))": 24029, + ");\\n\\n // @notice ": 24030, + "This is a ": 24031, + "Reserved": 24032, + "corresponding\\n * to the one signed with the\\n * ": 24033, + "x_n": 24034, + "{\\n using SafeMath for uint256": 24035, + ")\\n internal\\n view": 24036, + "log256(value) + ": 24037, + "log10(value) + ": 24038, + "assembly {\\n r := mload(add(signature, 0x20": 24039, + "hsiIndex": 24040, + "[i].": 24041, + "ONE_20) / ": 24042, + ");\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes calldata data\\n ": 24043, + "math/SafeMath.sol\"": 24044, + "new uint256[](": 24045, + "mstore8(ptr, ": 24046, + "disabling ": 24047, + "_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)": 24048, + "`]\\n * JSON-RPC method as part of EIP-712.\\n *\\n * See {recover}.\\n */\\n function ": 24049, + "accumulator": 24050, + "entries ": 24051, + "solidity-utils/contracts/helpers/": 24052, + "emits an event": 24053, + "computeDomainSeparator": 24054, + "_balances[owner] -= 1;\\n ": 24055, + "tokens.\\n */\\n function tokenOfOwnerByIndex(address owner, uint256 index": 24056, + "byte(mod(value, ": 24057, + ");\\n uint256 c = a - b": 24058, + "of its token list": 24059, + "updateMaxTxnAmount": 24060, + "at a given `index` of its token list": 24061, + ".\\n * Use along with {balanceOf} to enumerate ": 24062, + ");\\n _owner = address(0": 24063, + "UintToAddressMap": 24064, + "\"Swap amount cannot be higher than ": 24065, + "Corrections": 24066, + "ticketTokenId": 24067, + "leftwards to ": 24068, + ".sol\\u0027;\\n": 24069, + "Triggers ": 24070, + ".sol\\\";\\nimport \\\"../../utils/introspection/ERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721 is Context, ERC165, IERC721, IERC721Metadata {\\n using Address for address;\\n using Strings for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address": 24071, + ";\\n // ecrecover takes the signature parameters, and the only way to get them\\n // currently is to use assembly.\\n assembly {\\n r := mload(add(signature, 0x20": 24072, + "DRN": 24073, + "_balances[recipient] = _balances[recipient].add(amount);\\n emit Transfer": 24074, + "feeGrowthInside": 24075, + "interfaces/contracts/solidity-utils/helpers/": 24076, + "`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool": 24077, + "assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be ": 24078, + "ptr := add(buffer, ": 24079, + "emit OwnershipTransferred(_owner, address(0));\\n _owner = address(0": 24080, + ", uint reserveIn, uint reserveOut) external pure returns (": 24081, + "Returns an Ethereum Signed Message, created from a `hash`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash": 24082, + ", created from a\\n * `domainSeparator` and a `structHash`. This produces hash ": 24083, + ") {\\n // 32 is the length in bytes of hash,\\n // enforced by the type signature above\\n return keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n32\\\", hash": 24084, + ".sol\\\";\\nimport \\\"../../utils/Strings.sol\\\";\\nimport \\\"../../utils/introspection/ERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721 is Context, ERC165, IERC721, IERC721Metadata {\\n using Address for address;\\n using Strings for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address": 24085, + ") < value ? 1 : 0);\\n }\\n }\\n}\\n\"": 24086, + "\"//SPDX-License-Identifier: ": 24087, + "This is an alternative to {approve} that can be used as a mitigation for": 24088, + "[](tokenIds": 24089, + "10), _SYMBOLS": 24090, + "https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\\n * JSON-RPC method as part of EIP-712.\\n *\\n * See {recover}.\\n */\\n function ": 24091, + ".sol\\\";\\nimport \\\"../../utils/Address.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\nimport \\\"../../utils/Strings.sol\\\";\\nimport \\\"../../utils/introspection/ERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721 is Context, ERC165, IERC721, IERC721Metadata {\\n using Address for address;\\n using Strings for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address": 24092, + "IERC721.sol\\\";\\nimport \\\"./IERC721Receiver.sol\\\";\\nimport \\\"./extensions/IERC721Metadata": 24093, + "Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a ": 24094, + "(bytes32 hash) internal pure returns (bytes32) {\\n // 32 is the length in bytes of hash,\\n // enforced by the type signature above\\n return keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n32\\\", hash": 24095, + "string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : \\\"\\\";\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\\n * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\\n * by default, can be ": 24096, + ");\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n ": 24097, + "`newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {": 24098, + "defined by {EIP712}.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\"": 24099, + "SYMBOLS = \\\"0123456789abcdef": 24100, + "\\n * quantity - the amount to be transferred\\n *\\n * Calling conditions:\\n *\\n * - ": 24101, + ".\\n *\\n * startTokenId - the first token id to be transferred\\n * quantity - the amount to be transferred\\n *\\n * Calling conditions:\\n *\\n * - ": 24102, + "string memory buffer = new string(length": 24103, + "if (value == 0) break": 24104, + "owned by `owner` at a given `index` of its token list": 24105, + "interfaceId == 0x5b5e139f; // ": 24106, + "term = ((term * x": 24107, + "));\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Typed Data, created from a\\n * `domainSeparator` and a `structHash`. This produces hash ": 24108, + "corresponding\\n * to the one signed with the\\n * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\\n * JSON-RPC method as part of EIP-712.\\n *\\n * See {recover}.\\n */\\n function ": 24109, + "mstore8(ptr, byte(mod(value, ": 24110, + ".\\n * Use along with {balanceOf} to enumerate all of ": 24111, + "`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes calldata data\\n ": 24112, + "ptr := add(buffer, add(32, length": 24113, + "owned by `owner` at a given `index` of its token list.\\n * Use along with {balanceOf} to enumerate all of ": 24114, + "term = ((term * x) / ONE_20": 24115, + "));\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Typed Data, created from a\\n * `domainSeparator` and a `structHash`. This produces hash corresponding\\n * to the one signed with the\\n * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\\n * JSON-RPC method as part of EIP-712.\\n *\\n * See {recover}.\\n */\\n function ": 24116, + "mstore8(ptr, byte(mod(value, 10), _SYMBOLS": 24117, + "));\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Typed Data, created from a\\n * `domainSeparator` and a `structHash`. This produces hash corresponding\\n * to the one signed with the\\n * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\\n * JSON-RPC method as part of EIP-712.\\n *\\n * See {recover}.\\n */\\n function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash": 24118, + "\"AS": 24119, + "\"node_modules/": 24120, + "&%": 24121, + "'if": 24122, + "DutchAuction": 24123, + "Fore": 24124, + "PRE": 24125, + "SG": 24126, + "UInt": 24127, + "Wol": 24128, + "[_projectId": 24129, + "_balanceOf": 24130, + "_denominator": 24131, + "_src": 24132, + "c5": 24133, + "merk": 24134, + "sor": 24135, + "uki": 24136, + "{\\n\\n ": 24137, + "}\\n }": 24138, + "\\n );\\n\\n event ": 24139, + "reator": 24140, + "to,": 24141, + "\\n );\\n ": 24142, + ", address(0), ": 24143, + ", adminRole": 24144, + "// ": 24145, + "estim": 24146, + ") << ": 24147, + "attemp": 24148, + "tokenID": 24149, + "end := ": 24150, + "ical": 24151, + "to enable ": 24152, + "owners": 24153, + "controll": 24154, + "contributor": 24155, + "Tokens = ": 24156, + "True ": 24157, + "ERC20Snapshot": 24158, + ".\\n *\\n * Documentation for signature generation:": 24159, + "(address pair, bool ": 24160, + "data, ": 24161, + "AmountOut": 24162, + ");\\n}\"": 24163, + "), s": 24164, + "msgSender;\\n emit OwnershipTransferred(address(0), msgSender": 24165, + ") external virtual ": 24166, + "value - 1": 24167, + "that we ": 24168, + "contract itself": 24169, + "maxSupply ": 24170, + "maxInvocation": 24171, + "checks that ": 24172, + "mined": 24173, + "burning ": 24174, + "name() external view returns (string memory": 24175, + "] <= ": 24176, + "totalSupply} to enumerate all ": 24177, + "(\\n uint amountOut": 24178, + "swapAmount": 24179, + "alsend": 24180, + "periphery": 24181, + "will be": 24182, + "interface.\\n */\\n error ": 24183, + "for(uint256 ": 24184, + "\\n // ": 24185, + "\\n }\\n\\n function _": 24186, + "] = value": 24187, + "does ": 24188, + "hashing ": 24189, + ";\\n uint8 v": 24190, + "\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.": 24191, + "deadBlocks": 24192, + "delegated": 24193, + "000000000": 24194, + "0000000000": 24195, + "================================================================": 24196, + ")\\n result = ": 24197, + "disallowed": 24198, + "stopped ": 24199, + "block.timestamp > ": 24200, + "(address account) public view returns (": 24201, + ",,,": 24202, + "ile @openzeppelin/contracts/": 24203, + "temp := ": 24204, + "SALE": 24205, + "minted must be ": 24206, + "addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add": 24207, + "_NFT": 24208, + "MMMMMMMMMMMM": 24209, + ".sol\\\";\\nimport \\\"./IERC20": 24210, + "optionally ": 24211, + "doesn't perform any\\n * checks on the calling account.\\n *\\n * ": 24212, + "collectionSize": 24213, + "[0];\\n ": 24214, + ") {\\n // On the first call to nonReentrant, _notEntered will be true": 24215, + ") external;\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to": 24216, + "spender` cannot be the zero address.\\r\\n */\\r\\n function ": 24217, + "\\\"\\n );\\n require(": 24218, + "Votes: ": 24219, + "addLiquidityETH(\\n address token": 24220, + "-----------------------------------------------": 24221, + "_packedOwnerships[tokenId": 24222, + "chedule": 24223, + ");\\n }\\n\\n return (": 24224, + "/// @solidity memory-safe-assembly\\n assembly {\\n ": 24225, + "{\\n /**\\n * @dev Sets `value` as the allowance of `spender` ": 24226, + "InterfaceImplementer": 24227, + ";\\r\\n\\r\\n event ": 24228, + ")) {\\n ": 24229, + "early ": 24230, + "' statement": 24231, + "))\\n s := mload(add(signature, 0x40": 24232, + ".\\n // - ": 24233, + "other than the ": 24234, + "V3 ": 24235, + "Counters.sol\"": 24236, + ".\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns a token ID ": 24237, + "PROV": 24238, + "b068": 24239, + "normalizedWeights": 24240, + "shr(128": 24241, + "matches ": 24242, + "0.4.24": 24243, + ".add(amount);\\n ": 24244, + "merkle tree": 24245, + "``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n ": 24246, + "RATIO": 24247, + "treasuryWallet": 24248, + "\\\\xe3\\\\x81\\\\x8": 24249, + "AIR": 24250, + "token id to ": 24251, + "success := ": 24252, + "Active = false": 24253, + "---------------------------------------------------------------------------------------------------------------": 24254, + " | ": 24255, + "resultPtr, 1": 24256, + "a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it": 24257, + "extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Enumerable is ": 24258, + "IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional enumeration ": 24259, + "```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ": 24260, + "smart-": 24261, + "BASE": 24262, + "}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub": 24263, + "}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod": 24264, + "tokens.\\n */\\n function tokenByIndex(uint256 index": 24265, + "stored by the contract.\\n * Use along with {": 24266, + "modified ": 24267, + "_PRICE": 24268, + "counter._value = value - 1": 24269, + "at a given `index` of all the tokens ": 24270, + "bytes32 s;\\n uint8 v": 24271, + "\\u0026\\u0026 ": 24272, + "contract is not paused": 24273, + "Charity": 24274, + "in order to ": 24275, + "admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role": 24276, + "a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul": 24277, + "a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod": 24278, + "))\\n v := byte(0, mload(add(signature, 0x60": 24279, + ") {\\n bytes32 r;\\n bytes32 s;\\n uint8 v": 24280, + ")))\\n }\\n return ": 24281, + ";\\n\\n _;\\n\\n // ": 24282, + "from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received": 24283, + "\\n require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED;\\n\\n _;\\n\\n // ": 24284, + "(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(": 24285, + "Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received": 24286, + ") public returns (bool);\\n function ": 24287, + "Counter: decrement overflow": 24288, + "total amount of tokens stored by the contract.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns a token ID ": 24289, + "bytes4 retval) {\\n return retval == IERC721Receiver.onERC721Received.selector": 24290, + "2._\\n */\\n function recover": 24291, + "manualsend": 24292, + "signature.length == 65) {\\n bytes32 r;\\n bytes32 s;\\n uint8 v": 24293, + "uint256 value = counter._value": 24294, + "value > 0, \\\"Counter: decrement overflow": 24295, + "\\r\\n\\t\\tuint ": 24296, + "RoleRevoked(role, account, _msgSender());\\n }\\n }\\n}\\n\"": 24297, + ".\\n *\\n * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures": 24298, + ".sol@v4.": 24299, + "with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod": 24300, + "RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev ": 24301, + "Role(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n ": 24302, + "account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * ": 24303, + "a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub": 24304, + "foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it": 24305, + "Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ": 24306, + "} that receives the `r` and `vs` short-signature fields separately.\\n *\\n * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures": 24307, + "\\n * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\\n * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers": 24308, + "(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer": 24309, + "div(a, b, \\\"SafeMath: division by zero": 24310, + "`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes calldata data\\n ) external;\\n}\\n\"": 24311, + "'if' statement": 24312, + "Foreign": 24313, + ".\\n *\\n * Documentation for signature generation:\\n * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\\n * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers": 24314, + "totalSupply} to enumerate all tokens.\\n */\\n function tokenByIndex(uint256 index": 24315, + ") {\\n // On the first call to nonReentrant, _notEntered will be true\\n require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED;\\n\\n _;\\n\\n // ": 24316, + "))\\n s := mload(add(signature, 0x40))\\n v := byte(0, mload(add(signature, 0x60": 24317, + "stored by the contract.\\n * Use along with {totalSupply} to enumerate all tokens.\\n */\\n function tokenByIndex(uint256 index": 24318, + "at a given `index` of all the tokens stored by the contract.\\n * Use along with {totalSupply} to enumerate all tokens.\\n */\\n function tokenByIndex(uint256 index": 24319, + "total amount of tokens stored by the contract.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns a token ID owned by `owner` at a given `index` of its token list.\\n * Use along with {balanceOf} to enumerate all of ": 24320, + "Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function ": 24321, + "))\\n s := mload(add(signature, 0x40))\\n v := byte(0, mload(add(signature, 0x60)))\\n }\\n return ": 24322, + " \\n function ": 24323, + ")`, ": 24324, + "));\\n ": 24325, + ",000": 24326, + "-protocol/": 24327, + "07": 24328, + "1 to ": 24329, + "7 ": 24330, + "864": 24331, + ";\\r\\n }\\r\\n ": 24332, + "BoughtEarly": 24333, + "Cau": 24334, + "D76": 24335, + "Msg": 24336, + "Sample": 24337, + "See: ": 24338, + "Sniper": 24339, + "WR": 24340, + "[tx.origin": 24341, + "]\\n * ": 24342, + "_pair": 24343, + "_quantity": 24344, + "_pause": 24345, + "_MAX_MINT_ERC2309_QUANTITY_LIMIT": 24346, + "r and `": 24347, + "}\\n *\\n * _Available since v4.7._\\n */\\n function ": 24348, + "\\n ": 24349, + "to\\r\\n * ": 24350, + "adjust": 24351, + ", un": 24352, + ", owner, ": 24353, + ", AccessControl": 24354, + "return\\n _": 24355, + ") /": 24356, + "tokenOut": 24357, + "ER ": 24358, + "ERC3525": 24359, + "ToCurrent": 24360, + ": expired ": 24361, + ": do nothing": 24362, + "Read": 24363, + "er The ": 24364, + "mst": 24365, + " = 192": 24366, + "bucket ": 24367, + "data.length": 24368, + "and is not ": 24369, + "newBaseURI": 24370, + "\\n string(\\n abi.encodePacked(": 24371, + "Address(address ": 24372, + "from == address(0)": 24373, + "added": 24374, + "recipient,\\r\\n uint256 amount\\r\\n ": 24375, + "THE ": 24376, + "error: do nothing": 24377, + "> 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20": 24378, + "ApprovalToCurrent": 24379, + ");\\n\\n bool private ": 24380, + " is missing role ": 24381, + "Minting ": 24382, + ", \\\"Must ": 24383, + "swap(": 24384, + ").\\n // ": 24385, + " ": 24386, + "of the ECDSA signature ": 24387, + "Swap ": 24388, + "tokensOwed": 24389, + "buyDevelopmentFee": 24390, + "(_account": 24391, + "amount <= _": 24392, + "sellDevelopmentFee": 24393, + "mainBalance": 24394, + "feeBps": 24395, + "users ": 24396, + "error string. This ": 24397, + " - `": 24398, + "ERC721ACommon": 24399, + "} else ": 24400, + "MIN_": 24401, + "unchecked {\\n counter._value ": 24402, + ") internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(uint,": 24403, + "mapping(address => mapping(address => uint256": 24404, + "library SafeMath": 24405, + "type(int256": 24406, + " ": 24407, + "withdraw(": 24408, + "guard ": 24409, + "(((": 24410, + "assembly {\\r\\n ": 24411, + "Color": 24412, + "signer == address(0)": 24413, + "_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer": 24414, + "disableTransferDelay": 24415, + "A record of ": 24416, + "leaf, ": 24417, + "(\\n uint256 _editionId": 24418, + "(address(0), to, tokenId, _data": 24419, + "_holderTokens": 24420, + "} from \\\"@": 24421, + "Curve": 24422, + "base URI": 24423, + "() external view returns (uint256);\\n\\n function ": 24424, + "WithdrawRequest": 24425, + "permissioned ": 24426, + "\\r\\n * - ": 24427, + "\\\");\\n unchecked {\\n counter._value = value - 1": 24428, + "EIP-712 ": 24429, + "for (uint256 i = 0; i < _": 24430, + "}\\n }\\n\\n function decrement(Counter storage counter) internal {\\n ": 24431, + "letree": 24432, + "x & 0x": 24433, + "stitu": 24434, + "randomness": 24435, + "``owner``'s tokens.\\n */\\n function tokenOfOwnerByIndex(address owner, uint256 index": 24436, + "create new ": 24437, + "avoidable": 24438, + "_owners[tokenId];\\n require(": 24439, + "Math.log256(value) + ": 24440, + "Math.log10(value) + ": 24441, + "\"log(uint256,": 24442, + "circul": 24443, + "known as ": 24444, + ", bytes memory _data": 24445, + ";\\n require(value > 0, \\\"Counter: decrement overflow": 24446, + "Initializable: ": 24447, + "════": 24448, + "developmentFee": 24449, + "USDT": 24450, + "error == RecoverError.NoError": 24451, + "} that receives the `r and `": 24452, + "RecoverError error) private pure ": 24453, + ")\\\", p0, p1, p2));\\n\\t}\\n\\n\\tfunction log(uint ": 24454, + "throwError(RecoverError error) private pure ": 24455, + "double ": 24456, + "(address(0), RecoverError.InvalidSignatureS": 24457, + "(address(0), RecoverError.InvalidSignatureLength": 24458, + "Earn": 24459, + "` or error string. This ": 24460, + "toHexString(value, Math.log256(value) + ": 24461, + "Starting": 24462, + "▒▒▒▒▒▒▒▒": 24463, + "LzReceive": 24464, + "artblocksPrimarySales": 24465, + " =\\n keccak256(\\\"": 24466, + "(IERC20 token, address ": 24467, + "entially a ": 24468, + "Offset ": 24469, + "Two": 24470, + "length = Math.log10(value) + ": 24471, + "address payable) {\\n return ": 24472, + "TRANSFERS": 24473, + "_balances[account] = _balances[account].add(amount);\\n emit Transfer": 24474, + "RoleAdminChanged(role": 24475, + "WithoutFee": 24476, + ";\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\\n return\\n interfaceId == type(IERC721).interfaceId ||\\n interfaceId == type(IERC721Metadata).interfaceId ||\\n super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner": 24477, + "(301): 0 < s < secp256k1n ÷ 2 + 1, and for v in ": 24478, + ">`\\n * - `startTimestamp = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20": 24506, + "efficiency ": 24507, + "\\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(\\n _msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: ": 24508, + "signer, RecoverError.NoError": 24509, + "; // no error: do nothing": 24510, + "_owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n ": 24511, + "math/Math.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n enum Rounding {\\n Down, // Toward negative infinity\\n Up, // Toward infinity\\n Zero // Toward zero\\n }\\n\\n /**\\n * @dev Returns the largest of two numbers.\\n */\\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a > b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2;\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute.\\n return a == 0 ? 0 : (a - 1) / b + 1;\\n }\\n\\n /**\\n * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\\n * with further edits by Uniswap Labs also under MIT license": 24512, + "), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n ": 24513, + "multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n ": 24514, + "IERC721.sol\\\";\\nimport \\\"./IERC721Receiver.sol\\\";\\nimport \\\"./extensions/IERC721Metadata.sol\\\";\\nimport \\\"../../utils/Address.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\nimport \\\"../../utils/Strings.sol\\\";\\nimport \\\"../../utils/introspection/ERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721 is Context, ERC165, IERC721, IERC721Metadata {\\n using Address for address;\\n using Strings for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address": 24515, + ");\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId": 24516, + "merkletree": 24517, + ")\\n result = result * ": 24518, + "uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow": 24519, + "ForeignToken": 24520, + "of the ECDSA signature pair": 24521, + "} that receives the `r and `vs` short-signature fields separately": 24522, + "(301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (30": 24523, + "Wrappers over Solidity's arithmetic operations with added overflow\\n * checks.\\n *\\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\\n * in bugs, because programmers usually assume that an overflow raises an\\n * error, which is the standard behavior in high level programming languages.\\n * `SafeMath` restores this intuition by reverting the transaction when an\\n * operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it alway": 24524, + "slippage is unavoidable": 24525, + "+= 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow": 24526, + "Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow": 24527, + "Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1": 24528, + "'given ": 24529, + ")\\n ": 24530, + ")\\n {\\n ": 24531, + "-value ": 24532, + "0;\\n }\\n}\\n\"": 24533, + "1be": 24534, + "??": 24535, + "A0) {\\n return ": 24536, + "Esc": 24537, + "Each": 24538, + "Fic": 24539, + "Len": 24540, + "Leg": 24541, + "Listing": 24542, + "Match": 24543, + "MET": 24544, + "Pot": 24545, + "_round": 24546, + "_list": 24547, + "`_from": 24548, + "`.\\n */\\n event ": 24549, + "cast ": 24550, + "e, ": 24551, + "fits ": 24552, + "litt": 24553, + "ont": 24554, + "{\\n // ": 24555, + "}\\n ": 24556, + "\\n ) external view returns (": 24557, + "e in ": 24558, + "incorrectly ": 24559, + "returned by ": 24560, + "token, ": 24561, + "\\n (": 24562, + "amounts, ": 24563, + "verse ": 24564, + ") {\\n // ": 24565, + ") { break": 24566, + "maj": 24567, + "Refer": 24568, + "Trusted": 24569, + "value);\\n ": 24570, + "return false": 24571, + ",\\n uint256[] calldata ": 24572, + ". See ": 24573, + "while the ": 24574, + "indexOf": 24575, + "ting to ": 24576, + "mode": 24577, + "private constant ": 24578, + "), '": 24579, + "), 32": 24580, + "minted in ": 24581, + "zero address": 24582, + "Extra": 24583, + "token owner ": 24584, + "IERC20 {": 24585, + "checkTxLimit": 24586, + "ITE": 24587, + "balances.length": 24588, + "0._": 24589, + "] private ": 24590, + "0x6": 24591, + "ids.length": 24592, + "IERC721.onERC721Received.selector`.\\n */\\n function onERC721Received(\\n address operator,\\n address from,\\n uint256 tokenId,\\n bytes calldata data\\n ) external returns (bytes4);\\n}\\n\"": 24593, + "preJoinExitInvariant": 24594, + "{\\n require(": 24595, + "EIP ": 24596, + ";\\n uint256 internal ": 24597, + "\\n */\\n function toUint": 24598, + "https://forum.": 24599, + "s to normal ": 24600, + ".....": 24601, + ".\\n *\\n * Requirements:\\n *\\n * - `receiver` cannot be the zero address.\\n * - `feeNumerator` cannot be greater than the fee denominator.\\n */\\n function _set": 24602, + "received": 24603, + "deadline, uint8 v, bytes32 r, bytes32 s": 24604, + "Counters {\\n struct ": 24605, + ", and may ": 24606, + "9696": 24607, + "_isExcludedFromMaxWalletLimit": 24608, + "read and ": 24609, + "lastValue": 24610, + "s are made ": 24611, + "updateMarketingWallet": 24612, + "(address account, bool ": 24613, + "tempBytes": 24614, + "minted at ": 24615, + "ROLE_": 24616, + "claimed ": 24617, + "MAX_P": 24618, + "whenPaused(": 24619, + "Locked(": 24620, + "███████": 24621, + "maximum of ": 24622, + "\"Address: static ": 24623, + "ed, decrement": 24624, + "routerV2": 24625, + "same storage slot": 24626, + "External": 24627, + "{\\n // Ensure the ": 24628, + "\"@openzeppelin/contracts/utils/Counters.sol\"": 24629, + "math/SignedMath": 24630, + "Modifi": 24631, + "),\\n ": 24632, + "once the ": 24633, + "_unpause": 24634, + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./math/Math": 24635, + "mapping(address => bool) private ": 24636, + "\\u003c ": 24637, + ") private {\\n if (": 24638, + "manualswap": 24639, + "Add the ": 24640, + "(address from, address to, uint256 amount) internal virtual { ": 24641, + "$$$$$$": 24642, + ".\\n // This ": 24643, + "buybackFee": 24644, + ".\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\\n return\\n interfaceId == type(IERC721).interfaceId ||\\n interfaceId == type(IERC721Metadata).interfaceId ||\\n super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner": 24645, + ",\\n address indexed to": 24646, + "FRAX.": 24647, + " THE ": 24648, + ">> 128;\\n if (": 24649, + "(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `": 24650, + ");\\r\\n \\r\\n ": 24651, + "_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + ": 24652, + "\"Cannot set max ": 24653, + "express": 24654, + "entries.": 24655, + "TokenOwnership memory ownership = ": 24656, + "uint256 newAllowance = token.allowance(address(this), spender": 24657, + "_balances[account] = _balances[account].sub(amount, \\\"ERC20: burn ": 24658, + "ed or reset": 24659, + "InterestRate": 24660, + ");\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n */\\n function recover": 24661, + "Before = ": 24662, + ");\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender": 24663, + "abi.decode(returndata": 24664, + ");\\n\\n /**\\n * @dev Revert with an error if ": 24665, + "uniswapV2Router = IUniswapV2Router02": 24666, + ")\\n internal\\n pure\\n returns (": 24667, + "query the balance for ": 24668, + "_adapterParams": 24669, + "Range(": 24670, + "_addressData[to].balance ": 24671, + "while (true) {\\n ": 24672, + "group": 24673, + "APPROVAL": 24674, + ",\\n address to,\\n uint256 value\\n ) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.": 24675, + "equals 1": 24676, + "\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(": 24677, + "EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\\n // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (30": 24678, + "Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount": 24679, + "s `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer": 24680, + "Extension of {ERC20} that allows token holders to destroy both their own\\n * tokens and those that they have an allowance for, in a way that can be\\n * recognized off-chain (via event analysis).\\n */\\nabstract contract ERC20Burnable is Context, ERC20 {\\n /**\\n * @dev ": 24681, + "elegram": 24682, + "shifted by an ": 24683, + "Term": 24684, + "Destination": 24685, + "IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Enumerable is ": 24686, + "total amount of tokens stored by the contract.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns a token ID owned by `owner` at a given `index` of its token list.\\n * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.\\n */\\n function tokenOfOwnerByIndex(address owner, uint256 index": 24687, + ": expired deadline": 24688, + ". This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct ": 24689, + "Escrow": 24690, + ") { break ": 24691, + "\"Address: static call to non-contract\"": 24692, + "ed, decremented or reset": 24693, + ".\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\\n return\\n interfaceId == type(IERC721).interfaceId ||\\n interfaceId == type(IERC721Metadata).interfaceId ||\\n super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: ": 24694, + ">> 128;\\n if (x & 0x": 24695, + "(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer": 24696, + "\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: ": 24697, + "EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\\n // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\\n //\\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\\n // these malleable signatures as well": 24698, + ". This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1": 24699, + "(2": 24700, + "() private {\\n // ": 24701, + "51": 24702, + "AMP": 24703, + "AX96": 24704, + "Bin": 24705, + "FY": 24706, + "GDC": 24707, + "LATER": 24708, + "Otherwise": 24709, + "Pire": 24710, + "S,\\n InvalidSignature": 24711, + "S) {\\n revert(\\\"ECDSA: invalid signature ": 24712, + "Your ": 24713, + "],\\\"": 24714, + "_MINT": 24715, + "_nonces": 24716, + "`addr": 24717, + "laim": 24718, + "sac": 24719, + "tBurn": 24720, + "x/": 24721, + " `": 24722, + "\\n\\n ": 24723, + "toSwap": 24724, + "\\n } else if (error == RecoverError.InvalidSignature": 24725, + "uint48": 24726, + ") ||\\n ": 24727, + "` methods.": 24728, + "be called by ": 24729, + "\\n * and ": 24730, + "spender The ": 24731, + ". See {": 24732, + "at any ": 24733, + "set(": 24734, + "{\\n NoError": 24735, + "sender,\\r\\n address ": 24736, + "maxTokenId": 24737, + ").add(": 24738, + " * 10 ** ": 24739, + "Roles: ": 24740, + "\\n // and ": 24741, + "idTo": 24742, + "\\\");\\n }\\n }\\n\\n /**\\n * @dev Returns the ": 24743, + "Math.mul(": 24744, + "do-": 24745, + "ERC165Storage": 24746, + ";\\n /// @solidity memory-safe-assembly\\n assembly {\\n ": 24747, + "\"// SPDX-License-Identifier: MIT\\r\\n\\r\\n": 24748, + "eggs": 24749, + "which allows ": 24750, + "\\r\\n if (": 24751, + "+= uint64(": 24752, + "_minted": 24753, + "call or ": 24754, + "base64": 24755, + " - 1;\\n ": 24756, + "later.\\n let ": 24757, + ">> 8": 24758, + ";\\n if (": 24759, + ";\\n if (value == 0) break": 24760, + ") internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(bool,": 24761, + "AndSend": 24762, + "amountETHMarketing": 24763, + "transfer to a contract ": 24764, + "reverting on\\r\\n * overflow": 24765, + "IUniswapV2Router01 ": 24766, + " bits\\r\\n *\\r\\n * ": 24767, + "8888": 24768, + "_buyFee": 24769, + "_buyDevFee": 24770, + "() external onlyOwner ": 24771, + "interval": 24772, + ";\\n }\\n return buffer": 24773, + "Length,\\n InvalidSignature": 24774, + "Length) {\\n revert(\\\"ECDSA: invalid signature length": 24775, + "safeMint(address to, uint256 quantity": 24776, + "Address == ": 24777, + "Address != ": 24778, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary Strings {\\n bytes16 private constant _HEX_SYMBOLS = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = _HEX_SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n}\\n\"": 24779, + "delegate to ": 24780, + "let temp := ": 24781, + "████▌": 24782, + "ed = false": 24783, + "PublicMint": 24784, + "an address and is not ": 24785, + "1;\\n string memory buffer = new string(length": 24786, + ") public view returns (uint256) {\\n return ": 24787, + "-= x": 24788, + "15 ": 24789, + "Exceeded\"": 24790, + "max supply": 24791, + " (when the input is ": 24792, + "request.": 24793, + ") external returns (address pair": 24794, + "ptr--;\\n ": 24795, + "ptr;\\n /// @solidity memory-safe-assembly\\n assembly {\\n ": 24796, + ");\\n if (signer == address(0)": 24797, + "________": 24798, + "}\\n value /= 10": 24799, + "] = true;\\n emit ": 24800, + "_holderLastTransferTimestamp[tx.origin": 24801, + ") private view returns (bool) {\\n return ": 24802, + "}\\n }\\n\\n /// @dev ": 24803, + " * ": 24804, + ".\\n *\\n * _Available since v4.2._\\n */\\n function recover": 24805, + "))\\n }\\n value /= 10": 24806, + "/* solhint-disable ": 24807, + "more than zero": 24808, + "(\\r\\n address token": 24809, + "70E": 24810, + "HEXStake": 24811, + ", uint amount0, uint amount1": 24812, + "Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n ": 24813, + "Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i": 24814, + ");\\n }\\n _": 24815, + "(uint256 _pid": 24816, + "OPERATOR_FILTER_REGISTRY).code.length": 24817, + " between ": 24818, + "It's ": 24819, + "sequence ": 24820, + "RecoverError {\\n NoError": 24821, + "merkle tree ": 24822, + "AccessControl: account ": 24823, + "O(1), ": 24824, + "reserved": 24825, + "reset(Counter storage counter) internal {\\n ": 24826, + ".\\n if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20": 24827, + "Address, uint64 _": 24828, + "(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n uint256 ": 24829, + "proposal.": 24830, + ");\\n }\\n }\\n\\n /**\\n * @dev Returns the address that signed a hashed message (`hash`) with\\n * `signature`. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it.\\n */\\n function recover(bytes32 hash, bytes memory signature": 24831, + ";\\n\\nimport '@openzeppelin/contracts/": 24832, + ") {\\n revert(\\\"ECDSA: invalid signature": 24833, + ",\\n InvalidSignature,\\n InvalidSignature": 24834, + "{\\n if (error == RecoverError.NoError": 24835, + "_exists(tokenId), \\\"ERC721: operator query for nonexistent token": 24836, + "refundAddress": 24837, + "Equivalent to `_burn(tokenId, false": 24838, + "Equivalent to `_safeMint(to, quantity, ''": 24839, + ".\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover": 24840, + "if (a == 0": 24841, + ";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n uint256 ": 24842, + "Struct": 24843, + "64.64": 24844, + "tryRecover(hash, v, r, s);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev ": 24845, + "tryRecover(hash, v, r, s);\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover": 24846, + ") internal pure returns (address, RecoverError) {\\n bytes32 ": 24847, + ") internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, v, r, s);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev ": 24848, + "digits (": 24849, + "pointer, ": 24850, + "haveRight": 24851, + "leaf value": 24852, + ");\\n }\\n\\n // If the signature is valid (and not malleable), return the signer address\\n address signer = ecrecover(hash, v, r, s": 24853, + "administrator ": 24854, + ", signature);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover": 24855, + "if (b == 0) return (false, 0);\\n return (true, ": 24856, + "IDEXFactory": 24857, + "\\\");\\n } else if (error == RecoverError.InvalidSignatureS) {\\n revert(\\\"ECDSA: invalid signature ": 24858, + "\\\");\\n } else if (error == RecoverError.InvalidSignatureLength) {\\n revert(\\\"ECDSA: invalid signature length": 24859, + ") return (false, 0);\\n return (true, c": 24860, + "\\n * - `": 24861, + "returndatasize())\\n ": 24862, + ";\\n }\\n }\\n\\n function reset(Counter storage counter) internal {\\n ": 24863, + "mapping (address => bool) private ": 24864, + "address that signed a hashed message (`hash`) with\\n * `signature` or error string. This ": 24865, + "address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it.\\n *\\n * Documentation for signature generation:\\n * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\\n * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers": 24866, + "_RATIO": 24867, + "} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover": 24868, + ");\\n uint256 ptr;\\n /// @solidity memory-safe-assembly\\n assembly {\\n ": 24869, + ") internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, r, vs": 24870, + ") internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, signature);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover": 24871, + ");\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover": 24872, + "]\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover(bytes32 hash, bytes memory signature": 24873, + "safely transfer to a contract ": 24874, + "` operator.\\r\\n *\\r\\n * Requirements:\\r\\n *\\r\\n * - input must fit into ": 24875, + "_INTERFACE_ID_ERC721": 24876, + "token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n */\\ninterface IERC20": 24877, + ") {\\n return (address(0), RecoverError.InvalidSignature);\\n }\\n\\n return (": 24878, + "\\\";\\n uint8 private constant _ADDRESS_LENGTH = 20;\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n uint256 ": 24879, + ") {\\n return; // no error: do nothing": 24880, + ") internal pure returns (address, RecoverError) {\\n // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\\n // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\\n //\\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\\n // these malleable signatures as well": 24881, + "on its behalf": 24882, + "(address indexed sender, uint amount0, uint amount1": 24883, + "_toString(tokenId))": 24884, + "Some": 24885, + ");\\n } else {\\n return (address(0), RecoverError.InvalidSignatureLength": 24886, + "\"// SPDX-License-Identifier: GPL-2.0-or-later\\npragma solidity >=": 24887, + "IPancakeV3": 24888, + "SafeTransferLib": 24889, + "DECIMALS": 24890, + "bypass ": 24891, + "lower than 0.001% total supply.\"": 24892, + "address msgSender = _msgSender();\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender": 24893, + "__gap;\\n}\\n\"": 24894, + "senderBalance = _balances[sender];\\n require(": 24895, + "1);\\n }\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i": 24896, + "quantity of tokens minted must be ": 24897, + "(\\n SwapRequest memory ": 24898, + "Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented, decremented or reset": 24899, + "VRFConsumerBase": 24900, + "_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account": 24901, + "))\\n }\\n while (true) {\\n ": 24902, + "5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470": 24903, + "non-reverting calls are ": 24904, + "] = _SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer": 24905, + ".sol\\u0027;\\nimport \\u0027./": 24906, + "SYMBOLS = \\\"0123456789abcdef\\\";\\n uint8 private constant _ADDRESS_LENGTH = 20;\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n uint256 ": 24907, + "ptr := add(buffer, add(32, length))\\n }\\n while (true) {\\n ": 24908, + "mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n }\\n value /= 10": 24909, + "\"ASAP": 24910, + "\\n }\\n\\n function _throwError(RecoverError error) private pure ": 24911, + "/// @solidity memory-safe-assembly\\n assembly {\\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n }\\n value /= 10": 24912, + "foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControl": 24913, + "} that receives the `r` and `vs` short-signature fields separately.\\n *\\n * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover": 24914, + "at a given `index` of all the tokens stored by the contract.\\n * Use along with {totalSupply} to enumerate all tokens.\\n */\\n function tokenByIndex(uint256 index) external view returns (uint256);\\n}\\n\"": 24915, + "Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControl": 24916, + "))\\n s := mload(add(signature, 0x40))\\n v := byte(0, mload(add(signature, 0x60)))\\n }\\n return tryRecover(hash, v, r, s": 24917, + "signer, RecoverError.NoError);\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n */\\n function recover": 24918, + ")\\n result = result * 0x": 24919, + "} that receives the `r and `vs` short-signature fields separately.\\n *\\n * _Available since v4.2._\\n */\\n function recover": 24920, + "A0) {\\n return (address(0), RecoverError.InvalidSignatureS": 24921, + "LATERAL": 24922, + "S,\\n InvalidSignatureV": 24923, + "\\n } else if (error == RecoverError.InvalidSignature) {\\n revert(\\\"ECDSA: invalid signature": 24924, + "\\\");\\n }\\n }\\n\\n /**\\n * @dev Returns the address that signed a hashed message (`hash`) with\\n * `signature` or error string. This ": 24925, + "+= uint64(quantity": 24926, + ";\\n if (value == 0) break;\\n }\\n return buffer": 24927, + "reverting on\\r\\n * overflow (when the input is ": 24928, + "Length,\\n InvalidSignatureS,\\n InvalidSignatureV": 24929, + "1;\\n string memory buffer = new string(length);\\n uint256 ptr;\\n /// @solidity memory-safe-assembly\\n assembly {\\n ": 24930, + "ptr--;\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n }\\n value /= 10": 24931, + ");\\n if (signer == address(0)) {\\n return (address(0), RecoverError.InvalidSignature);\\n }\\n\\n return (": 24932, + "Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n return ": 24933, + "RecoverError {\\n NoError,\\n InvalidSignature,\\n InvalidSignature": 24934, + ".\\n if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\\n return (address(0), RecoverError.InvalidSignatureS": 24935, + ");\\n }\\n }\\n\\n /**\\n * @dev Returns the address that signed a hashed message (`hash`) with\\n * `signature`. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it.\\n */\\n function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, signature);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover": 24936, + "{\\n if (error == RecoverError.NoError) {\\n return; // no error: do nothing": 24937, + "tryRecover(hash, v, r, s);\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\\n *\\n * _Available since v4.2._\\n */\\n function recover": 24938, + ") internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, v, r, s);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Message, created from a `hash`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash": 24939, + ");\\n }\\n\\n // If the signature is valid (and not malleable), return the signer address\\n address signer = ecrecover(hash, v, r, s);\\n if (signer == address(0)) {\\n return (address(0), RecoverError.InvalidSignature);\\n }\\n\\n return (": 24940, + "\\\");\\n } else if (error == RecoverError.InvalidSignatureS) {\\n revert(\\\"ECDSA: invalid signature 's' value": 24941, + "\\\");\\n } else if (error == RecoverError.InvalidSignatureLength) {\\n revert(\\\"ECDSA: invalid signature length\\\");\\n } else if (error == RecoverError.InvalidSignatureS) {\\n revert(\\\"ECDSA: invalid signature 's' value": 24942, + ";\\n }\\n }\\n\\n function reset(Counter storage counter) internal {\\n counter._value = ": 24943, + "address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it.\\n *\\n * Documentation for signature generation:\\n * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\\n * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover(bytes32 hash, bytes memory signature": 24944, + ") internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, r, vs);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover": 24945, + "safely transfer to a contract that does not ": 24946, + ") internal pure returns (address, RecoverError) {\\n // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\\n // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\\n //\\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\\n // these malleable signatures as well.\\n if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\\n return (address(0), RecoverError.InvalidSignatureS": 24947, + ");\\n } else {\\n return (address(0), RecoverError.InvalidSignatureLength);\\n }\\n }\\n\\n /**\\n * @dev Returns the address that signed a hashed message (`hash`) with\\n * `signature`. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it.\\n */\\n function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, signature);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover": 24948, + "1);\\n }\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = _SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer": 24949, + "quantity of tokens minted must be more than zero": 24950, + "ptr := add(buffer, add(32, length))\\n }\\n while (true) {\\n ptr--;\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n }\\n value /= 10": 24951, + "\\n }\\n\\n function _throwError(RecoverError error) private pure {\\n if (error == RecoverError.NoError) {\\n return; // no error: do nothing": 24952, + "\\n } else if (error == RecoverError.InvalidSignature) {\\n revert(\\\"ECDSA: invalid signature\\\");\\n } else if (error == RecoverError.InvalidSignatureLength) {\\n revert(\\\"ECDSA: invalid signature length\\\");\\n } else if (error == RecoverError.InvalidSignatureS) {\\n revert(\\\"ECDSA: invalid signature 's' value": 24953, + "\\\");\\n }\\n }\\n\\n /**\\n * @dev Returns the address that signed a hashed message (`hash`) with\\n * `signature` or error string. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it.\\n *\\n * Documentation for signature generation:\\n * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\\n * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover(bytes32 hash, bytes memory signature": 24954, + ";\\n if (value == 0) break;\\n }\\n return buffer;\\n }\\n }\\n\\n /**\\n * @dev ": 24955, + "1;\\n string memory buffer = new string(length);\\n uint256 ptr;\\n /// @solidity memory-safe-assembly\\n assembly {\\n ptr := add(buffer, add(32, length))\\n }\\n while (true) {\\n ptr--;\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n }\\n value /= 10": 24956, + "RecoverError {\\n NoError,\\n InvalidSignature,\\n InvalidSignatureLength,\\n InvalidSignatureS,\\n InvalidSignatureV": 24957, + ");\\n }\\n\\n // If the signature is valid (and not malleable), return the signer address\\n address signer = ecrecover(hash, v, r, s);\\n if (signer == address(0)) {\\n return (address(0), RecoverError.InvalidSignature);\\n }\\n\\n return (signer, RecoverError.NoError);\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n */\\n function recover": 24958, + ");\\n } else {\\n return (address(0), RecoverError.InvalidSignatureLength);\\n }\\n }\\n\\n /**\\n * @dev Returns the address that signed a hashed message (`hash`) with\\n * `signature`. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it.\\n */\\n function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, signature);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\\n *\\n * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover": 24959, + "\\n }\\n\\n function _throwError(RecoverError error) private pure {\\n if (error == RecoverError.NoError) {\\n return; // no error: do nothing\\n } else if (error == RecoverError.InvalidSignature) {\\n revert(\\\"ECDSA: invalid signature\\\");\\n } else if (error == RecoverError.InvalidSignatureLength) {\\n revert(\\\"ECDSA: invalid signature length\\\");\\n } else if (error == RecoverError.InvalidSignatureS) {\\n revert(\\\"ECDSA: invalid signature 's' value": 24960, + "1;\\n string memory buffer = new string(length);\\n uint256 ptr;\\n /// @solidity memory-safe-assembly\\n assembly {\\n ptr := add(buffer, add(32, length))\\n }\\n while (true) {\\n ptr--;\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n }\\n value /= 10;\\n if (value == 0) break;\\n }\\n return buffer;\\n }\\n }\\n\\n /**\\n * @dev ": 24961, + " will ": 24962, + "\"x": 24963, + "();\\n }\\n}\\n\"": 24964, + ".\\n /// @dev ": 24965, + ";\\n * ": 24966, + "BX96": 24967, + "Bunn": 24968, + "Da": 24969, + "K ": 24970, + "Low": 24971, + "VG": 24972, + "[{\\\"": 24973, + "_key": 24974, + "_pausers": 24975, + "`address(0)": 24976, + "c ": 24977, + "pancake": 24978, + "x, ": 24979, + "yield ": 24980, + "{\\r\\n function ": 24981, + " | ": 24982, + "\\n\\n uint256 ": 24983, + "\\n mapping (address => ": 24984, + "integr": 24985, + ", 32": 24986, + ");\\n ": 24987, + "isPoint": 24988, + "ERC1820": 24989, + "d the ": 24990, + "/**\\n * @notice ": 24991, + "usto": 24992, + ": INVALID": 24993, + ") { // ": 24994, + "Reach": 24995, + "was a ": 24996, + "an initial ": 24997, + "Increase": 24998, + "setMaxWallet": 24999, + "totalBalance": 25000, + "olidity ": 25001, + "bytes32(": 25002, + "require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token": 25003, + "******": 25004, + "token is not ": 25005, + "The caller must own the token or be an approved operator.\\n */\\n error ": 25006, + ";\\n\\n/// @notice ": 25007, + ");\\n\\n /**\\n@notice ": 25008, + "length.\\n ": 25009, + "are a ": 25010, + "this call": 25011, + " (https://github.com/": 25012, + "126": 25013, + "// Solidity ": 25014, + "SwapTokensAtAmount": 25015, + "pragma solidity =": 25016, + "\\\");\\n }\\n\\n ": 25017, + "notify": 25018, + ";\\n string public ": 25019, + "uint88": 25020, + "[] storage ": 25021, + "pointers": 25022, + "payable(msg.sender": 25023, + "liquidityWallet": 25024, + "\\r\\n uint256 ": 25025, + "\\r\\n */": 25026, + "\\\");\\n\\n uint256 ": 25027, + "::mint": 25028, + "reads from the ": 25029, + "&&\\r\\n ": 25030, + "refresh": 25031, + "Model": 25032, + "updateProject": 25033, + "E_RATE_": 25034, + ".\\n event ": 25035, + "slot\\n ": 25036, + "address owner,\\r\\n address ": 25037, + "required role": 25038, + "LockUntil": 25039, + "Note that this ": 25040, + ");\\r\\n }\\r\\n ": 25041, + "Strings.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./math/Math": 25042, + "WARD": 25043, + ".\\n */\\n error Invalid": 25044, + "Direct": 25045, + "authorize": 25046, + "collateral_amount": 25047, + "quantity <= ": 25048, + "TRACT": 25049, + ". This is a ": 25050, + "uriPrefix": 25051, + "{\\n /**\\n * @dev Emitted when the ": 25052, + "directly to the ": 25053, + "TradingOpen": 25054, + "multiple reads from the ": 25055, + "mapping(address => bool) ": 25056, + "];\\n if (": 25057, + "PERMIT_TYPEHASH, owner, ": 25058, + "deleteDefaultRoyalty": 25059, + "some tokens ": 25060, + "copyright ": 25061, + "\"log(bool,": 25062, + "rightmost ": 25063, + "devWalletUpdated": 25064, + "much": 25065, + "validity": 25066, + "matches the ": 25067, + "burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ": 25068, + " to prevent multiple reads from the ": 25069, + "resetTokenRoyalty": 25070, + "traits.": 25071, + "redemption ": 25072, + "_exists(tokenId), \\\"ERC721: approved query for nonexistent token": 25073, + "isExcludedFromFees[to]": 25074, + "pause is ": 25075, + "_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, \\\"ERC20: decreased allowance below zero\\\")": 25076, + "frax": 25077, + ",\\n uint liquidity,\\n uint amountAMin,\\n uint amountBMin,\\n address to,\\n uint deadline": 25078, + "whenNotPaused {\\n _": 25079, + ") return 0": 25080, + "royaltyInfo(uint256 tokenId, uint256 ": 25081, + "────": 25082, + "uint256) {\\r\\n ": 25083, + "balanceOf(to) <= ": 25084, + "Percentage = ": 25085, + "Name = ": 25086, + "] = false;\\n emit ": 25087, + "^^^^": 25088, + ") internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n": 25089, + " {\\n enum RecoverError {\\n NoError,\\n InvalidSignature,\\n InvalidSignatureLength,\\n InvalidSignatureS,\\n InvalidSignatureV": 25090, + "(\\n address tokenA,\\n address tokenB,\\n uint liquidity,\\n uint amountAMin,\\n uint amountBMin,\\n address to,\\n uint deadline": 25091, + "allows children to implement an emergency ": 25092, + "(sender, recipient, amount);\\n\\n uint256 currentAllowance = ": 25093, + "manualBurnFrequency": 25094, + "schem": 25095, + "elapsed": 25096, + ",\\n uint256[] memory balances,\\n uint256 lastChangeBlock": 25097, + ");\\r\\n }\\r\\n\\r\\n /**\\r\\n * @dev Returns the downcasted ": 25098, + "OpenZeppelin Contracts v4.4.1 (": 25099, + "Execut": 25100, + "eip1967.proxy.implementation": 25101, + "fungible ": 25102, + "replay ": 25103, + "address cannot be 0\"": 25104, + "createPair(address tokenA, address tokenB) external returns (address pair": 25105, + " /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(": 25106, + "payee ": 25107, + "// We read and ": 25108, + "(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId": 25109, + "Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\\n *\\n * These functions can be used to verify that a message was signed by the holder\\n * of the private keys of a given address.\\n */\\nlibrary ECDSA {\\n enum RecoverError {\\n NoError,\\n InvalidSignature,\\n InvalidSignatureLength,\\n InvalidSignatureS,\\n InvalidSignatureV": 25110, + "automatedMarketMakerPairs[to] ": 25111, + "string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token": 25112, + "\\n mapping(uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping(address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping(uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping(address => mapping(address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\\n return\\n interfaceId == type(IERC721).interfaceId ||\\n interfaceId == type(IERC721Metadata).interfaceId ||\\n super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: ": 25113, + "_packedAddressData[owner] ": 25114, + ".add(amount);\\n _balances[account] = _balances[account].add(amount);\\n emit Transfer": 25115, + "Wrappers over Solidity's arithmetic operations with added overflow\\n * checks.\\n *\\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\\n * in bugs, because programmers usually assume that an overflow raises an\\n * error, which is the standard behavior in high level programming languages.\\n * `SafeMath` restores this intuition by reverting the transaction when an\\n * operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition": 25116, + "] private __gap;\\n}\\n\"": 25117, + "same storage slot\\n uint256 ": 25118, + "abi.decode(returndata, (": 25119, + "Extension of {ERC20} that allows token holders to destroy both their own\\n * tokens and those that they have an allowance for, in a way that can be\\n * recognized off-chain (via event analysis).\\n */\\nabstract contract ERC20Burnable is Context, ERC20 {\\n /**\\n * @dev Destroys `amount` tokens from the caller.\\n *\\n * See {ERC20-_burn}.\\n */\\n function burn(uint256 amount) public virtual {\\n _burn(_msgSender(), amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, deducting from the caller's\\n * allowance.\\n *\\n * See {ERC20-_burn} and {ERC20-allowance}.\\n *\\n * Requirements:\\n *\\n * - the caller must have allowance for ``accounts``'s tokens of at least\\n * `amount`.\\n */\\n function burnFrom(address account, uint256 amount) public virtual ": 25120, + ". This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n\\n function reset(Counter storage counter) internal {\\n counter._value = ": 25121, + "Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n\\n function reset(Counter storage counter) internal {\\n counter._value = ": 25122, + " to prevent multiple reads from the same storage slot\\n uint256 ": 25123, + "royaltyInfo(uint256 tokenId, uint256 salePrice": 25124, + ") internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(": 25125, + "// We read and store the ": 25126, + " on ": 25127, + "(success, ": 25128, + "(see ": 25129, + "3cc": 25130, + "677": 25131, + "73": 25132, + "Because ": 25133, + "Ech": 25134, + "Hed": 25135, + "Termin": 25136, + "]=": 25137, + "_nonce": 25138, + "_rewards": 25139, + "away ": 25140, + "a_n": 25141, + "f9": 25142, + "grows ": 25143, + "hiddenMetadataUri": 25144, + "treasury ": 25145, + "▐████▌": 25146, + "\\n uint256 public constant ": 25147, + "s array ": 25148, + ", timestamp": 25149, + "enter": 25150, + "\\\"\\n ": 25151, + "\\\");\\r\\n": 25152, + "pul": 25153, + "fromDelegate": 25154, + "Tokens that ": 25155, + "Owner ": 25156, + "calls ": 25157, + "calls.": 25158, + "ERC20 `": 25159, + " = 64": 25160, + "priz": 25161, + "essentially a ": 25162, + "ableOperatorFilterer": 25163, + "getPrior": 25164, + "added, ": 25165, + "zero case": 25166, + "recipient, ": 25167, + "sender is only ": 25168, + "Exclusion": 25169, + "maxWall": 25170, + "(uint256 id_": 25171, + "token amount": 25172, + "s.\\r\\n *\\r\\n * ": 25173, + "balances,\\n ": 25174, + "symbol() external view returns (string memory": 25175, + "having ": 25176, + "this module": 25177, + "swapEnabled = true": 25178, + "fore": 25179, + "Requirements": 25180, + "zero.\\n * - `": 25181, + "WalletLimit": 25182, + "tokens\"": 25183, + "string memory str": 25184, + "s, but ": 25185, + "` is equal": 25186, + "balance = (": 25187, + "balance * _": 25188, + "block.chain": 25189, + "is not in the ": 25190, + "ourselves": 25191, + "__/ ": 25192, + ",\\n address(this),\\n ": 25193, + "Updates the ": 25194, + " The ": 25195, + "gradient": 25196, + " {\\n event ": 25197, + "use `": 25198, + ");\\r\\n return ": 25199, + "E_OFFSET": 25200, + "Principal": 25201, + "ing the contract ": 25202, + ";\\n\\n uint256 ": 25203, + "e.\\n */\\nabstract contract ": 25204, + "transfer to the zero address.\\n */\\n error ": 25205, + ")\\n int256 constant x": 25206, + "We write the ": 25207, + " bits\\n */\\n function toUint": 25208, + "claimToken": 25209, + "_address, ": 25210, + "while loop": 25211, + "also handles the ": 25212, + "() public view virtual override returns (string memory) {\\r\\n return ": 25213, + "values\\n ": 25214, + "invalid token ID": 25215, + "Guard": 25216, + "Claim ": 25217, + "initializes ": 25218, + ");\\r\\n }\\r\\n\\r\\n ": 25219, + ".\\n */\\n error TransferFromIncorrectOwner": 25220, + ".\\n */\\n error MintZeroQuantity": 25221, + ") external;\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved": 25222, + "28f": 25223, + ".\\r\\n *\\r\\n * Counterpart to Solidity's `": 25224, + "shareholder": 25225, + "Exceeded": 25226, + "configuration": 25227, + "max supply ": 25228, + "mint to the zero address.\\n */\\n error ": 25229, + "umulative ": 25230, + "globally ": 25231, + ".sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/": 25232, + "permission to ": 25233, + "need to be ": 25234, + ".\\n if (": 25235, + "sometimes ": 25236, + "\\n */\\n modifier only": 25237, + "Cache(": 25238, + "network ": 25239, + ";\\r\\n }\\r\\n\\r\\n function set": 25240, + "most digit": 25241, + ";\\n _expTable": 25242, + "Deposited": 25243, + "();\\n\\n /**\\n * The caller must own the token or be an approved operator.\\n */\\n error ": 25244, + "();\\n\\n /**\\n * The quantity of tokens minted must be more than zero": 25245, + "x -= x": 25246, + "Entry": 25247, + "during construction": 25248, + ");\\n\\n emit ": 25249, + "ensure(": 25250, + "ensures that ": 25251, + "ONE) / _": 25252, + "Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with GSN ": 25253, + "ERC721Receiver interface.\\n */\\n error ": 25254, + "Note: the ": 25255, + "push(": 25256, + "Decl": 25257, + "Info memory ": 25258, + "= (votingPower": 25259, + ", address p3) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(bool,": 25260, + ", string memory p3) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(bool,": 25261, + ", bool p3) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(bool,": 25262, + "TransferToNonERC721ReceiverImplementer();\\n\\n /**\\n * Cannot ": 25263, + "lightweight ": 25264, + "receiver, uint96 feeNumerator": 25265, + "those cases ": 25266, + "(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer": 25267, + "USDC": 25268, + "\\\";\\n string private ": 25269, + "Rate = ": 25270, + "burn(uint256 tokenId) internal virtual {\\n _burn(tokenId, false);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId, bool approvalCheck": 25271, + "SHIP": 25272, + ");\\n }\\n}\\n\\n": 25273, + "TransferCallerNotOwnerNorApproved();\\n\\n /**\\n * The token ": 25274, + "Permit {\\n /**\\n * @dev Sets `value` as the allowance of `spender` ": 25275, + "b79b": 25276, + "function that delegates ": 25277, + "PendingAdmin": 25278, + "utils/cryptography/MerkleProof": 25279, + "();\\n\\n /**\\n * Cannot query the balance for ": 25280, + "();\\n\\n /**\\n * Cannot safely transfer to a contract that does not ": 25281, + "();\\n\\n /**\\n * Cannot mint to the zero address.\\n */\\n error ": 25282, + "processMultiProofCalldata": 25283, + "Box": 25284, + "GrowthInvariant": 25285, + "leftmost digit": 25286, + "0, // slippage is unavoidable": 25287, + "Correspond": 25288, + "GivenIn": 25289, + "OWNERSHIP": 25290, + "free memory pointer to ": 25291, + "the zero address.\\n */\\n error BalanceQueryForZeroAddress": 25292, + "OwnerQueryForNonexistentToken();\\n\\n /**\\n * The caller must own the token or be an approved operator.\\n */\\n error ": 25293, + "response ": 25294, + "String operations.\\n */\\nlibrary Strings {\\n bytes16 private constant _SYMBOLS = \\\"0123456789abcdef\\\";\\n uint8 private constant _ADDRESS_LENGTH = 20;\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n uint256 ": 25295, + "Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size": 25296, + "ApprovalCallerNotOwnerNorApproved();\\n\\n /**\\n * The token does not exist.\\n */\\n error ": 25297, + "TransferToZeroAddress();\\n\\n /**\\n * The token does not exist.\\n */\\n error ": 25298, + "accumulated ": 25299, + " != 0) {\\n votingPower ": 25300, + " != 0) {\\n balance = (": 25301, + "();\\n\\n /**\\n * The token does not exist.\\n */\\n error OwnerQueryForNonexistentToken();\\n\\n /**\\n * The caller must own the token or be an approved operator.\\n */\\n error ": 25302, + " that also handles the ": 25303, + "blacklist ": 25304, + "must be owned by `from`.\\n */\\n error TransferFromIncorrectOwner": 25305, + ".\\n _onlyOwnerOrSelf": 25306, + ") internal virtual override {\\n super._beforeTokenTransfer": 25307, + "limits ": 25308, + "EEEEEEEEEEEEEEEE": 25309, + "_allowances[sender][_msgSender()];\\n require(": 25310, + "mstore(0x00, 0x": 25311, + "41EC": 25312, + "6733": 25313, + "have the following ": 25314, + "to.code.length != 0": 25315, + "_price(": 25316, + "a = (a * ": 25317, + "emit OwnershipTransferred(_owner, newOwner": 25318, + ")`.\\n */\\n function _safeMint(address to, uint256 quantity": 25319, + ")`.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n _burn(tokenId, false);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId, bool approvalCheck": 25320, + "\"Swap amount cannot be lower than 0.001% total supply.\"": 25321, + "`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes calldata data\\n ) external;\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to": 25322, + "permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature ": 25323, + ";\\n seriesSum += term": 25324, + ";\\n seriesSum += num / ": 25325, + "MintToZeroAddress();\\n\\n /**\\n * The quantity of tokens minted must be more than zero": 25326, + "(\\n address token,\\n uint liquidity,\\n uint amountTokenMin,\\n uint amountETHMin,\\n address to,\\n uint deadline,\\n bool approveMax, uint8 v, bytes32 r, bytes32 s": 25327, + "the owner or contract itself": 25328, + "enough to ": 25329, + "following is essentially a ": 25330, + "inner ": 25331, + "callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance": 25332, + "trigger ": 25333, + "string memory name, string memory symbol": 25334, + "require(b > 0, errorMessage);\\n return ": 25335, + "pool-utils/contracts/": 25336, + ")\\n }\\n assembly {\\n ": 25337, + "unclaimedPool": 25338, + "maxTotalMintableBy": 25339, + "x >= x": 25340, + "r := shr(f, r)\\n }\\n assembly {\\n ": 25341, + "_balances[recipient] += amount;\\n\\n emit Transfer": 25342, + "ERROR": 25343, + "uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(": 25344, + " != 0) ratio = (ratio * 0x": 25345, + "ByOwnerOrGovernance {\\n ": 25346, + ");\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal virtual {\\n require(ERC721.ownerOf(tokenId) == from, \\\"ERC721: ": 25347, + "_operatorApprovals[_msgSender()][operator] = approved;\\n emit ApprovalForAll": 25348, + "signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature ": 25349, + "blockForPenaltyEnd": 25350, + "_balances[recipient] = _balances[recipient].add(amount);\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` ": 25351, + ".\\n *\\n * startTokenId - the first token id to be transferred\\n * quantity - the amount to be transferred\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, `from`'s ": 25352, + "term = ((term * x) / ONE_20) / ": 25353, + ") {\\n // On the first call to nonReentrant, _notEntered will be true\\n require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED;\\n\\n _;\\n\\n // By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200)\\n _status = _NOT_ENTERED;\\n }\\n}\\n\"": 25354, + "toHexString(value, Math.log256(value) + 1);\\n }\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = _SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer": 25355, + "length = Math.log10(value) + 1;\\n string memory buffer = new string(length);\\n uint256 ptr;\\n /// @solidity memory-safe-assembly\\n assembly {\\n ptr := add(buffer, add(32, length))\\n }\\n while (true) {\\n ptr--;\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n }\\n value /= 10;\\n if (value == 0) break;\\n }\\n return buffer;\\n }\\n }\\n\\n /**\\n * @dev ": 25356, + "address payable) {\\n return msg.sender": 25357, + "IERC721.sol\\\";\\nimport \\\"./IERC721Receiver.sol\\\";\\nimport \\\"./extensions/IERC721Metadata.sol\\\";\\nimport \\\"../../utils/Address.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\nimport \\\"../../utils/Strings.sol\\\";\\nimport \\\"../../utils/introspection/ERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721 is Context, ERC165, IERC721, IERC721Metadata {\\n using Address for address;\\n using Strings for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping(uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping(address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping(uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping(address => mapping(address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\\n return\\n interfaceId == type(IERC721).interfaceId ||\\n interfaceId == type(IERC721Metadata).interfaceId ||\\n super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: ": 25358, + "little ": 25359, + "do-while loop": 25360, + "Address, uint64 _nonce": 25361, + "Equivalent to `_burn(tokenId, false)`.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n _burn(tokenId, false);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId, bool approvalCheck": 25362, + "Equivalent to `_safeMint(to, quantity, '')`.\\n */\\n function _safeMint(address to, uint256 quantity": 25363, + "token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n */\\ninterface IERC20Permit {\\n /**\\n * @dev Sets `value` as the allowance of `spender` ": 25364, + "Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n return toHexString(value, Math.log256(value) + 1);\\n }\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = _SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer": 25365, + "The caller must own the token or be an approved operator.\\n */\\n error ApprovalCallerNotOwnerNorApproved();\\n\\n /**\\n * The token does not exist.\\n */\\n error ": 25366, + "rightmost dig": 25367, + ",\\n uint256[] memory balances,\\n uint256 lastChangeBlock,\\n uint256 protocolSwapFeePercentage": 25368, + "(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId);\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId": 25369, + "Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n\\n function reset(Counter storage counter) internal {\\n counter._value = 0;\\n }\\n}\\n\"": 25370, + "sender is only the owner or contract itself": 25371, + "maxWallPercent": 25372, + "balance * _ONE) / _": 25373, + "transfer to the zero address.\\n */\\n error TransferToZeroAddress();\\n\\n /**\\n * The token does not exist.\\n */\\n error ": 25374, + "We write the string ": 25375, + ".\\n */\\n error MintZeroQuantity();\\n\\n /**\\n * The token does not exist.\\n */\\n error OwnerQueryForNonexistentToken();\\n\\n /**\\n * The caller must own the token or be an approved operator.\\n */\\n error ": 25376, + "ERC721Receiver interface.\\n */\\n error TransferToNonERC721ReceiverImplementer();\\n\\n /**\\n * Cannot ": 25377, + "= (votingPower * _expTable": 25378, + "TransferCallerNotOwnerNorApproved();\\n\\n /**\\n * The token must be owned by `from`.\\n */\\n error TransferFromIncorrectOwner": 25379, + "();\\n\\n /**\\n * Cannot query the balance for the zero address.\\n */\\n error BalanceQueryForZeroAddress": 25380, + "();\\n\\n /**\\n * Cannot mint to the zero address.\\n */\\n error MintToZeroAddress();\\n\\n /**\\n * The quantity of tokens minted must be more than zero": 25381, + "String operations.\\n */\\nlibrary Strings {\\n bytes16 private constant _SYMBOLS = \\\"0123456789abcdef\\\";\\n uint8 private constant _ADDRESS_LENGTH = 20;\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n uint256 length = Math.log10(value) + 1;\\n string memory buffer = new string(length);\\n uint256 ptr;\\n /// @solidity memory-safe-assembly\\n assembly {\\n ptr := add(buffer, add(32, length))\\n }\\n while (true) {\\n ptr--;\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n }\\n value /= 10;\\n if (value == 0) break;\\n }\\n return buffer;\\n }\\n }\\n\\n /**\\n * @dev ": 25382, + " != 0) {\\n votingPower = (votingPower * _expTable": 25383, + " != 0) {\\n balance = (balance * _ONE) / _": 25384, + " that also handles the zero case": 25385, + "a = (a * ONE_20) / ": 25386, + "following is essentially a do-while loop": 25387, + "The caller must own the token or be an approved operator.\\n */\\n error ApprovalCallerNotOwnerNorApproved();\\n\\n /**\\n * The token does not exist.\\n */\\n error ApprovalQueryForNonexistentToken": 25388, + "sender is only the owner or contract itself.\\n _onlyOwnerOrSelf": 25389, + "transfer to the zero address.\\n */\\n error TransferToZeroAddress();\\n\\n /**\\n * The token does not exist.\\n */\\n error URIQueryForNonexistentToken": 25390, + ".\\n */\\n error MintZeroQuantity();\\n\\n /**\\n * The token does not exist.\\n */\\n error OwnerQueryForNonexistentToken();\\n\\n /**\\n * The caller must own the token or be an approved operator.\\n */\\n error TransferCallerNotOwnerNorApproved();\\n\\n /**\\n * The token must be owned by `from`.\\n */\\n error TransferFromIncorrectOwner": 25391, + "ERC721Receiver interface.\\n */\\n error TransferToNonERC721ReceiverImplementer();\\n\\n /**\\n * Cannot transfer to the zero address.\\n */\\n error TransferToZeroAddress();\\n\\n /**\\n * The token does not exist.\\n */\\n error URIQueryForNonexistentToken": 25392, + "();\\n\\n /**\\n * Cannot query the balance for the zero address.\\n */\\n error BalanceQueryForZeroAddress();\\n\\n /**\\n * Cannot mint to the zero address.\\n */\\n error MintToZeroAddress();\\n\\n /**\\n * The quantity of tokens minted must be more than zero": 25393, + " != 0) {\\n balance = (balance * _ONE) / _expTable": 25394, + "following is essentially a do-while loop that also handles the zero case": 25395, + ".\\n */\\n error MintZeroQuantity();\\n\\n /**\\n * The token does not exist.\\n */\\n error OwnerQueryForNonexistentToken();\\n\\n /**\\n * The caller must own the token or be an approved operator.\\n */\\n error TransferCallerNotOwnerNorApproved();\\n\\n /**\\n * The token must be owned by `from`.\\n */\\n error TransferFromIncorrectOwner();\\n\\n /**\\n * Cannot safely transfer to a contract that does not ": 25396, + "();\\n\\n /**\\n * Cannot query the balance for the zero address.\\n */\\n error BalanceQueryForZeroAddress();\\n\\n /**\\n * Cannot mint to the zero address.\\n */\\n error MintToZeroAddress();\\n\\n /**\\n * The quantity of tokens minted must be more than zero.\\n */\\n error MintZeroQuantity();\\n\\n /**\\n * The token does not exist.\\n */\\n error OwnerQueryForNonexistentToken();\\n\\n /**\\n * The caller must own the token or be an approved operator.\\n */\\n error TransferCallerNotOwnerNorApproved();\\n\\n /**\\n * The token must be owned by `from`.\\n */\\n error TransferFromIncorrectOwner();\\n\\n /**\\n * Cannot safely transfer to a contract that does not ": 25397, + "(newImplementation": 25398, + ")[": 25399, + "-value": 25400, + ".\\n */\\n\\n": 25401, + "2c8": 25402, + "400": 25403, + "79": 25404, + "81": 25405, + ";\\n }\\n ": 25406, + "=\\n ": 25407, + "O(n": 25408, + "WOOL": 25409, + "];\\n\\n ": 25410, + "_y": 25411, + "_no": 25412, + "_signature": 25413, + "_presale": 25414, + "gt": 25415, + "rice": 25416, + "sample ": 25417, + "tMarketing": 25418, + "\\npragma solidity 0.8.17": 25419, + "\\n error ": 25420, + "\\n ) private pure returns (": 25421, + "into": 25422, + "top": 25423, + ", deadline": 25424, + "//\\n // ": 25425, + "uint256[]": 25426, + "orter": 25427, + ") == 0": 25428, + "token.safeTransfer(": 25429, + "end, ": 25430, + "end);\\n // Reentrancy protection": 25431, + "a to ": 25432, + "publicDrop": 25433, + "TokenAddress": 25434, + "TokenContract": 25435, + "or not the ": 25436, + ".\\n *\\n * To ": 25437, + "internal immutable ": 25438, + "} is ": 25439, + "newBeacon": 25440, + "), 1": 25441, + "proceed": 25442, + ", uint256 toTokenId": 25443, + "The easiest way to bubble the revert reason is using memory via assembly": 25444, + "ETHAmount": 25445, + "ceed ": 25446, + "totalSupply * ": 25447, + "logic ": 25448, + "bytes32 value": 25449, + "bool isApprovedOrOwner": 25450, + "IPrice": 25451, + "\\n // `": 25452, + "utility": 25453, + "\\n */\\n function mint": 25454, + "uint80 ": 25455, + "of\\n // the ": 25456, + "Id = _": 25457, + "0, a ": 25458, + ") internal virtual returns (": 25459, + "orted ": 25460, + "only if the ": 25461, + "\\\\/": 25462, + "supported, ": 25463, + "reading and ": 25464, + ".\\n for (uint256 i = 0; i < ": 25465, + ".length;\\n uint256 ": 25466, + ", address indexed to": 25467, + ", address indexed from, address indexed ": 25468, + "we don't ": 25469, + "feeswap": 25470, + ".\\n mapping(uint256 => ": 25471, + "()` ": 25472, + ") {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token": 25473, + ")\\n revert ": 25474, + ".sol\\\";\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary Strings {\\n bytes16 private constant _SYMBOLS = \\\"0123456789abcdef\\\";\\n uint8 private constant _ADDRESS_LENGTH = 20;\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n uint256 length = Math.log10(value) + 1;\\n string memory buffer = new string(length);\\n uint256 ptr;\\n /// @solidity memory-safe-assembly\\n assembly {\\n ptr := add(buffer, add(32, length))\\n }\\n while (true) {\\n ptr--;\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n }\\n value /= 10;\\n if (value == 0) break;\\n }\\n return buffer;\\n }\\n }\\n\\n /**\\n * @dev ": 25475, + "withdrawal": 25476, + "claimable": 25477, + "by\\n // ": 25478, + ";\\n emit Un": 25479, + "while still ": 25480, + "subscribe ": 25481, + "key-value ": 25482, + "delegate call to non-contract\"": 25483, + "stakeShares": 25484, + "\"Address: delegate call to non-contract\"": 25485, + "uint128 _": 25486, + "funding ": 25487, + "position.": 25488, + "at the given ": 25489, + "ByPartition": 25490, + ".\\n\\n ": 25491, + "_operatorData": 25492, + "LibPart": 25493, + "basisPoints": 25494, + ") internal virtual {}\\r\\n": 25495, + "_initialSupply": 25496, + "\\\");\\r\\n ": 25497, + "permissions": 25498, + "224f810": 25499, + "60b79b": 25500, + "on behalf": 25501, + "3cd4": 25502, + "dF41EC": 25503, + "Afa08": 25504, + "s. Some": 25505, + "BatchHead": 25506, + "AAeB6": 25507, + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAccessControl": 25508, + "(\\r\\n address sender,\\r\\n address ": 25509, + "bitLength": 25510, + ")\\n )\\n )\\n ": 25511, + "Myth": 25512, + "WITHDRA": 25513, + "address(0x0": 25514, + "Software": 25515, + "████████████████": 25516, + "JoinExitSupply": 25517, + "ddA7": 25518, + "s[i] ": 25519, + "int128 ": 25520, + "unchecked {\\n ++i;\\n }\\n ": 25521, + "transmissions": 25522, + "ERC1967Upgrade": 25523, + "-call-value": 25524, + ") public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved": 25525, + "522A7": 25526, + "33333333333333333333333333333333": 25527, + "igned": 25528, + "sender must be an ": 25529, + "resultPtr := add(": 25530, + "votingPowerHistory": 25531, + ", previous": 25532, + "you to ": 25533, + "end of the memory ": 25534, + "Elaps": 25535, + "autoBurnLiquidityPairTokens": 25536, + "allowed SeaDrop ": 25537, + "6CddA7": 25538, + ") internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(\\\"\\\\x19\\\\x01\\\", domainSeparator, structHash": 25539, + "observationCardinality": 25540, + "ERC721Enumerable: owner ": 25541, + "unit of ": 25542, + "FA224f810": 25543, + "\"Buy transfer amount exceeds the maxTransactionAmount.\"": 25544, + "Optimized ": 25545, + "calculate the length ": 25546, + "OperatorNotAllowed": 25547, + "Fragment": 25548, + "Deprecated": 25549, + "bytes32 internal constant _": 25550, + "000000000000AAeB6": 25551, + "FundingCycle": 25552, + "1806733": 25553, + "dCeB6": 25554, + "\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer": 25555, + "address(uint160(_packedOwnershipOf(tokenId": 25556, + ") internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data": 25557, + "(\\n bytes32 poolId,\\n address sender,\\n address recipient,\\n uint256[] memory balances,\\n uint256 lastChangeBlock,\\n uint256 protocolSwapFeePercentage": 25558, + "'0' ": 25559, + ", plus ": 25560, + ", but we add ": 25561, + "assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ": 25562, + "));\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Typed Data, created from a\\n * `domainSeparator` and a `structHash`. This produces hash corresponding\\n * to the one signed with the\\n * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\\n * JSON-RPC method as part of EIP-712.\\n *\\n * See {recover}.\\n */\\n function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(\\\"\\\\x19\\\\x01\\\", domainSeparator, structHash": 25563, + "D7670E": 25564, + "string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,0": 25565, + "{\\n // Ensure the sender is only the owner or contract itself.\\n _onlyOwnerOrSelf": 25566, + "Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer": 25567, + "string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n ": 25568, + "3cc6CddA7": 25569, + ") external;\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev ": 25570, + ") {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n ": 25571, + "60b79bAfa08": 25572, + "3cd4E": 25573, + "dF41ECFA224f810": 25574, + "522A71806733": 25575, + "000000000000AAeB6D7670E": 25576, + "3cc6CddA760b79bAfa08": 25577, + "dF41ECFA224f810dCeB6": 25578, + "522A718067333cd4E": 25579, + "000000000000AAeB6D7670E522A718067333cd4E": 25580, + "3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6": 25581, + "(id": 25582, + "(quantity == 1": 25583, + "+1 ": 25584, + "+°.": 25585, + "+.*•´.*:": 25586, + ".is": 25587, + "20000": 25588, + "9.2": 25589, + ":*.´": 25590, + "Dif": 25591, + "IUni": 25592, + "JO": 25593, + "Last ": 25594, + "OG": 25595, + "Pl": 25596, + "Word ": 25597, + "_(": 25598, + "_decimal": 25599, + "_sellDevFee": 25600, + "_merkleProof": 25601, + "_entries": 25602, + "`_projectId": 25603, + "d0": 25604, + "ep ": 25605, + "game": 25606, + "hdrn": 25607, + "ib": 25608, + "pf": 25609, + "smart contract": 25610, + "sqr": 25611, + "˚.°": 25612, + "˚•´": 25613, + "˚:*.´": 25614, + "•*.": 25615, + "ones ": 25616, + "\\n address ": 25617, + "ticall": 25618, + "tition ": 25619, + "instruction": 25620, + "\\n * ": 25621, + ", address(this": 25622, + "room": 25623, + "owed and ": 25624, + "tokenHolder": 25625, + "endar": 25626, + "end - ": 25627, + "ise": 25628, + "isPair": 25629, + "quote(": 25630, + "ToWithdraw": 25631, + "` until ": 25632, + "uint256 end": 25633, + "straction": 25634, + "view\\r\\n returns (": 25635, + "spent": 25636, + "return ownership": 25637, + " = 160": 25638, + "spenderAllowance": 25639, + "contract.\\n *\\n * ": 25640, + ") {\\n assembly {\\n ": 25641, + "for multiple ": 25642, + ";\\n } else if (": 25643, + "bytes32[] ": 25644, + "Returns to normal ": 25645, + "value of `": 25646, + "zero address\"": 25647, + "substraction": 25648, + "OfTokens": 25649, + "(uint256 shares": 25650, + "token The token ": 25651, + "swapEnabled ": 25652, + "when setting ": 25653, + "id_ ": 25654, + ") {\\n _": 25655, + ",\\n uint256 _amount": 25656, + "constants ": 25657, + "// Stor": 25658, + "_transfer(_msgSender(), recipient, amount": 25659, + "ed by the call": 25660, + "PerAddress": 25661, + "PerWallet": 25662, + "\\n\\t* ": 25663, + "bytes memory return": 25664, + "can be prov": 25665, + "start` ": 25666, + "ATE": 25667, + "ORAC": 25668, + "feeProtocol": 25669, + "`tokenId` from `from` to `to": 25670, + "\\r\\n * ": 25671, + "PoolId": 25672, + "PoolPayout": 25673, + "from, to, value": 25674, + ")\\n returns (bool)\\n {\\n return ": 25675, + "_isExcludedFromMax": 25676, + "Confirmation": 25677, + "marketingAmt": 25678, + "arily ": 25679, + "signed 64.64": 25680, + ",\\r\\n uint amountToken": 25681, + "one of ": 25682, + "trying to ": 25683, + ");\\n _require(": 25684, + "paused\"": 25685, + "Added(": 25686, + "withdrawal ": 25687, + "tokenId would have to be 2**256": 25688, + "RoyaltyPercentage": 25689, + ");\\n return true;\\n }\\n\\n /**\\n * @notice ": 25690, + ".sol\\\";\\nimport \\\"./interfaces/": 25691, + "Arbitrary ": 25692, + "Assign": 25693, + " / 2": 25694, + "Paused(address account": 25695, + "universe": 25696, + "quantity - 1": 25697, + "Exceeded(": 25698, + "\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.17": 25699, + "addLiquidityETH{value: ": 25700, + "role to ": 25701, + "requested": 25702, + "rewardsDuration": 25703, + "managed": 25704, + "MerkleProof ": 25705, + "fixed point": 25706, + "_msgSenderERC721A() != ": 25707, + "that can be minted ": 25708, + "enumerable ": 25709, + "require(b <= a, errorMessage": 25710, + "members ": 25711, + ")\\n // Move the pointer ": 25712, + "IERC721A.sol\"": 25713, + "queue ": 25714, + "queued": 25715, + "ed to be a part of a ": 25716, + "mintingAllowed": 25717, + ";\\n }\\n }\\n\\n /**\\n * @dev Returns the ": 25718, + "{\\n _paused = false": 25719, + "Update the free memory pointer to ": 25720, + ")\\r\\n public\\r\\n ": 25721, + "for {\\n ": 25722, + "int248": 25723, + "_packedOwnerships[index] = ": 25724, + "0.5.0;\\n\\ninterface ": 25725, + "MULT": 25726, + ", _msgSender()), \\\"": 25727, + "Determin": 25728, + "-in-": 25729, + "AccessControl: sender must be an ": 25730, + " * (10 ** ": 25731, + "address is zero": 25732, + ".selector, to, value": 25733, + "uint256)')) == ": 25734, + "triggered by ": 25735, + ";\\n }\\n\\n /**\\n * @notice ": 25736, + ".*°.": 25737, + "}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom": 25738, + "\\n /// ": 25739, + "lastIndex = ": 25740, + "*.˚•´": 25741, + "project `_projectId": 25742, + "contract is paused, and ": 25743, + "MetaTransaction": 25744, + "lifted by ": 25745, + ".°:°•.°": 25746, + "°.´": 25747, + "burned = true": 25748, + "pause is trigge": 25749, + "2,\\n 2,\\n 2,\\n 2,\\n 2,\\n 2,\\n 2,\\n 2,\\n ": 25750, + ".\\n uint256 private constant ": 25751, + "Face": 25752, + "'s index to prevent multiple reads from the same storage slot\\n uint256 ": 25753, + "Unpaused(address account": 25754, + "\\\"}],\\\"": 25755, + "The address which ": 25756, + "prettier-ignore\\n ": 25757, + ";\\n }\\n _afterTokenTransfers(address(0), to, startTokenId, quantity);\\n }\\n\\n /**\\n * @dev Mint": 25758, + "_treasuryFee": 25759, + "(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(": 25760, + ") / _ONE;\\n }\\n if (t & 0x": 25761, + "paused.\\n */\\n modifier whenNotPaused(": 25762, + "repetition ": 25763, + "\"Sell transfer amount exceeds the maxTransactionAmount.\"": 25764, + "CLUD": 25765, + "invocations": 25766, + "approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address": 25767, + "Delegatee": 25768, + "meant to be called ": 25769, + "Traits": 25770, + "in unpaused state": 25771, + "•°:°.´": 25772, + "s\\\":[{\\\"": 25773, + "p0) internal view {\\n\\t\\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature(\\\"log(bytes": 25774, + "Provider ": 25775, + "covered work": 25776, + ".\\r\\n *\\r\\n * Emits a {Transfer} event.\\r\\n */\\r\\n function ": 25777, + "Penalties": 25778, + ";\\n uint256 private immutable _expTable": 25779, + "paused = true;\\n emit ": 25780, + "External interface of AccessControl ": 25781, + ".call{ value: amount ": 25782, + "Composable": 25783, + "sentinel ": 25784, + "malicious ": 25785, + ");\\n return a % b;\\n }\\n}\\n\"": 25786, + "All three of these values are immutable: they can only be set once during\\n * construction": 25787, + "ImpliedRate": 25788, + "(address(this).balance": 25789, + "Triggers stopped ": 25790, + "bytes4 retval) {\\n return retval == IERC721Receiver.onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n ": 25791, + "IUniswapV2Router01 {\\n function ": 25792, + ") return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the ": 25793, + "require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n ": 25794, + "pause is lifted by ": 25795, + "(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(": 25796, + "bool isApprovedOrOwner = (": 25797, + "funding cy": 25798, + "s. Some\\n * ": 25799, + ") public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer": 25800, + "));\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Typed Data, created from a\\n * `domainSeparator` and a `structHash`. This produces hash corresponding\\n * to the one signed with the\\n * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\\n * JSON-RPC method as part of EIP-712.\\n *\\n * See {recover}.\\n */\\n function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(\\\"\\\\x19\\\\x01\\\", domainSeparator, structHash));\\n }\\n}\\n\"": 25801, + "˚.°*.˚•´": 25802, + "can be proved to be a part of a ": 25803, + "ORACLE": 25804, + "_msgSenderERC721A() != owner": 25805, + "AccessControl: sender must be an admin to ": 25806, + ".*°.˚:*.´": 25807, + "pause is triggered by ": 25808, + "approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n ": 25809, + "˚.°*.˚•´.°:°•.°": 25810, + "can be proved to be a part of a Merkle ": 25811, + ")\\r\\n ": 25812, + ")\\r\\n ": 25813, + ",\\r\\n\\t\\t": 25814, + ".totalSupply": 25815, + ".\\n *\\n * ": 25816, + "43": 25817, + ">'": 25818, + "Full": 25819, + "Grou": 25820, + "Native": 25821, + "Vari": 25822, + "[_address": 25823, + "] ": 25824, + "_0": 25825, + "_, address ": 25826, + "_block": 25827, + "_delegates": 25828, + "_released": 25829, + "`{IERC20-approve}": 25830, + "a952": 25831, + "f0": 25832, + "pol": 25833, + "\\n/// @dev ": 25834, + "\\n mapping(address => ": 25835, + "s need to ": 25836, + "\\n }\\n\\n return result": 25837, + "ad1be": 25838, + "ande": 25839, + "deal ": 25840, + "the functions ": 25841, + "ended to be ": 25842, + "isBurn": 25843, + "to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer": 25844, + "to keep the ": 25845, + "to calculate the length ": 25846, + "address for ": 25847, + "// At ": 25848, + "// Add the ": 25849, + "uint256 contains ": 25850, + "owner,\\n uint256 ": 25851, + "of your contract": 25852, + "return packed": 25853, + " = 10": 25854, + "contractTokens": 25855, + "Inu": 25856, + "s/contracts/": 25857, + "mode ": 25858, + "Codec": 25859, + "eight": 25860, + "from on-chain ": 25861, + "by access": 25862, + "as possible": 25863, + ") public onlyOwner ": 25864, + "sub(_": 25865, + "163c": 25866, + "checked for ": 25867, + "-------": 25868, + "name;\\n ": 25869, + "are supported": 25870, + ";\\n\\n /**": 25871, + "pauser ": 25872, + "zero.\\n ": 25873, + "balanceOf[": 25874, + "role\"": 25875, + "/contracts/\"": 25876, + "event log": 25877, + "Data[": 25878, + "**********": 25879, + ";\\n mapping(address => bool) public ": 25880, + "See {processMultiProof": 25881, + "s, which ": 25882, + "_isBlacklisted": 25883, + "_isBlack": 25884, + "constructor(\\n address ": 25885, + "lockup": 25886, + "set on ": 25887, + "remote": 25888, + "roles[role].members[account": 25889, + ") public view virtual returns (bool) {\\n return _": 25890, + "in the `": 25891, + "= _values(set._inner": 25892, + "int256(": 25893, + "ice-": 25894, + ", amountB": 25895, + ", amount, \\\"": 25896, + "user-f": 25897, + ", and its ": 25898, + "_balances[address(this)": 25899, + "(from, to": 25900, + "Operator ": 25901, + ");\\n }\\n\\n function _burn": 25902, + "Enabled(": 25903, + "Logic": 25904, + "ERC721A/": 25905, + "ating role": 25906, + "s are put in plac": 25907, + "we allocate ": 25908, + "rency ": 25909, + "Initializable ": 25910, + "55a4": 25911, + "modifiers `": 25912, + "modifiers are put in plac": 25913, + "(1e6": 25914, + ")\\n let ": 25915, + ";\\r\\n if (": 25916, + "withdrawStuck": 25917, + "they will not be ": 25918, + "claims": 25919, + "already been ": 25920, + "message digest ": 25921, + "utils/Context.sol\\\";\\nimport \\\"../": 25922, + "AUTHOR": 25923, + "with the last ": 25924, + ",\\n \\\"": 25925, + "to the pointer": 25926, + "ownership slot ": 25927, + "larger ": 25928, + ", 0x04": 25929, + "uint256[] memory tokenId": 25930, + "applications may ": 25931, + "crab": 25932, + "protocolFee": 25933, + "` and `whenPaused": 25934, + "make room": 25935, + "high = ": 25936, + "digits. ": 25937, + ");\\n }\\n\\n /**\\n * @dev See {IERC721Enumerable-": 25938, + "per digit": 25939, + "_initialize": 25940, + "start < stop": 25941, + ".sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/": 25942, + "Mask ": 25943, + "if it does": 25944, + ".\\n */\\nabstract contract ERC721": 25945, + ", bpt": 25946, + "DividendOf": 25947, + "BaseURI(string memory ": 25948, + "that can be triggered by ": 25949, + "mechanism that can be triggered by ": 25950, + "StakeLength": 25951, + "enumerability": 25952, + "enumerating role": 25953, + "InterfaceLP": 25954, + "(sender, recipient, amount);\\n\\n ": 25955, + "s. See {processMultiProof": 25956, + "extcodehash": 25957, + "address[] calldata path,\\r\\n address to,\\r\\n uint deadline": 25958, + "CEED": 25959, + "store\\n }\\n\\n return result": 25960, + ";\\n if (absTick & 0x": 25961, + "daa952": 25962, + "_approve(owner, spender, value": 25963, + "\\n // If the ": 25964, + " The ": 25965, + "`, which can be appli": 25966, + "E =\\n ": 25967, + "revoked": 25968, + "UriResolver": 25969, + ");\\n\\n if (approvalCheck": 25970, + "whenNotPaused` and `whenPaused": 25971, + "batchSwap": 25972, + "bytes32[] memory store ": 25973, + "state variable": 25974, + "avoid-call-value": 25975, + "allow enumerating role": 25976, + "df523": 25977, + "df252": 25978, + "Contract module which allows children to implement an emergency ": 25979, + "BptOut": 25980, + ");\\n\\n /**\\n * @dev Emitted when the pause is lifted by ": 25981, + " | (": 25982, + "_packedOwnerships[index": 25983, + "b3ef": 25984, + ",\\n \\\"": 25985, + "IERC20 {\\n function ": 25986, + ";\\n\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/": 25987, + "ba7f": 25988, + "_developmentFee": 25989, + "result := store\\n }\\n\\n return result": 25990, + "wrapped ": 25991, + "draft-EIP712": 25992, + "9b69": 25993, + "details.\\n *\\n * _Available since v4.7._\\n */\\n function ": 25994, + "Modifier that ": 25995, + "18 decimal": 25996, + "from != msg.sender": 25997, + "uint256 result) {\\n // ": 25998, + "benefit from on-chain ": 25999, + "PPPPPPPP": 26000, + "imilar to ": 26001, + "The maximum value of a ": 26002, + "fc378": 26003, + "off-chain means ": 26004, + "_implementation()": 26005, + "WordCodec": 26006, + "UpgradeabilityProxy ": 26007, + ". Note that they will not be ": 26008, + "yield-protocol/": 26009, + "''''''''": 26010, + "(bytes memory s": 26011, + "modifies the ": 26012, + "Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n}\\n\"": 26013, + "4a116": 26014, + "32 bytes leftwards to ": 26015, + "nonces[owner].": 26016, + "c2b068": 26017, + "Mismatch": 26018, + "(\\n address sender,\\n address recipient,\\n uint256 amount\\n ) public virtual override returns (bool) {\\n _transfer": 26019, + "computed hash": 26020, + "(pair, value": 26021, + "keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n\\\", ": 26022, + "78 digits (": 26023, + "78 digits. ": 26024, + "simply including ": 26025, + "character to the pointer": 26026, + "pause() internal virtual whenPaused ": 26027, + "hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit ": 26028, + "hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit ": 26029, + "type `id": 26030, + "} for details.\\n *\\n * _Available since v4.7._\\n */\\n function ": 26031, + "Cache the end of the memory ": 26032, + "except through off-chain means ": 26033, + "denominated in ": 26034, + "(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\"": 26035, + "Keep dividing ": 26036, + "Expiry": 26037, + "the address returned by `": 26038, + "_callTokens": 26039, + "fromTokenId, uint256 toTokenId": 26040, + "0xddf252": 26041, + "MerkleProof.verify": 26042, + "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470": 26043, + ";\\n }\\n\\n /**\\n * @dev Returns true if the contract is paused, and ": 26044, + "onlyAllowedOperator(from) {\\n super.safeTransferFrom": 26045, + "scaling factor": 26046, + "(uint256 x, uint256 y": 26047, + ";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with GSN ": 26048, + ".sendValue": 26049, + "IVISOR": 26050, + ", only once the ": 26051, + "therefore ": 26052, + ".addr = from": 26053, + "CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof": 26054, + "Cooldown": 26055, + ", for those cases ": 26056, + "\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.6.0": 26057, + "),\\n \\\"ERC721: transfer to non ERC721Receiver implementer\\\"\\n );\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer": 26058, + "_balances[sender] = _balances[sender].sub(amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n ": 26059, + "_totalSupply = _totalSupply.sub(amount);\\n emit Transfer": 26060, + "similar to the ": 26061, + "1 byte per digit": 26062, + "Write the character to the pointer": 26063, + "an authorized account": 26064, + ".\\n // The following is essentially a do-while loop that also handles the zero case": 26065, + "false otherwise.\\n */\\n function paused(": 26066, + "later.\\n let end := ": 26067, + "ustodi": 26068, + ". This is a lightweight ": 26069, + "whenNotPaused {\\n _paused = true;\\n emit ": 26070, + "this module, only once the ": 26071, + "block.chainid == ": 26072, + "ing the contract event log": 26073, + "28f55a4": 26074, + "leftmost digit.\\n // The following is essentially a do-while loop that also handles the zero case": 26075, + "2c89b69": 26076, + ";\\n emit Unpaused(": 26077, + "owed and to whom": 26078, + "Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by ": 26079, + "members except through off-chain means ": 26080, + "{\\n _paused = false;\\n emit Unpaused(": 26081, + "`{IERC20-approve}`, the ": 26082, + "ad1be2c89b69": 26083, + "the functions of your contract": 26084, + "to keep the free memory pointer ": 26085, + "uint256 contains 78 digits (": 26086, + "by accessing the contract event log": 26087, + "163c4a116": 26088, + "= _values(set._inner);\\n ": 26089, + "modifiers `whenNotPaused` and `whenPaused": 26090, + "applications may benefit from on-chain ": 26091, + "make room for the ": 26092, + "mechanism that can be triggered by an authorized account": 26093, + "enumerability, for those cases ": 26094, + "daa952ba7f": 26095, + "`, which can be applied ": 26096, + "bytes32[] memory store = _values(set._inner);\\n ": 26097, + "df523b3ef": 26098, + "Contract module which allows children to implement an emergency stop": 26099, + "The maximum value of a uint256 contains 78 digits (": 26100, + "fc378daa952ba7f": 26101, + ". Note that they will not be pausable ": 26102, + "32 bytes leftwards to make room for the ": 26103, + "c2b068fc378daa952ba7f": 26104, + "simply including this module, only once the ": 26105, + "Cache the end of the memory to calculate the length ": 26106, + "the address returned by `_implementation()": 26107, + "0xddf252ad1be2c89b69": 26108, + ";\\n }\\n\\n /**\\n * @dev Returns true if the contract is paused, and false otherwise.\\n */\\n function paused(": 26109, + "CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.\\n *\\n * _Available since v4.7._\\n */\\n function ": 26110, + ". This is a lightweight version ": 26111, + "whenNotPaused {\\n _paused = true;\\n emit Paused(": 26112, + "28f55a4df523b3ef": 26113, + "leftmost digit.\\n // The following is essentially a do-while loop that also handles the zero case.\\n // ": 26114, + "members except through off-chain means by accessing the contract event log": 26115, + "the functions of your contract. Note that they will not be pausable ": 26116, + "163c4a11628f55a4df523b3ef": 26117, + "modifiers `whenNotPaused` and `whenPaused`, which can be applied ": 26118, + "applications may benefit from on-chain enumerability, for those cases ": 26119, + "The maximum value of a uint256 contains 78 digits (1 byte per digit": 26120, + "c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef": 26121, + "simply including this module, only once the modifiers are put in plac": 26122, + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef": 26123, + "applications may benefit from on-chain enumerability, for those cases see": 26124, + "\"Max ": 26125, + "(config.": 26126, + ".\\r\\n *\\r\\n * ": 26127, + "/'": 26128, + "0 = ": 26129, + "5000": 26130, + "? (": 26131, + "Crowd": 26132, + "Dy": 26133, + "Ful": 26134, + "IRateProvider": 26135, + "Need": 26136, + "SP": 26137, + "Since ": 26138, + "UQ": 26139, + "] ": 26140, + "_throwError": 26141, + "_efficientHash": 26142, + "_withdrawableDividend": 26143, + "`temp": 26144, + "bn": 26145, + "book": 26146, + "e\"": 26147, + "i] = _": 26148, + "mi": 26149, + "mim": 26150, + "ryp": 26151, + "r, r": 26152, + "soft": 26153, + "ta ": 26154, + "urn": 26155, + "vouch": 26156, + "\\n ) internal view virtual returns (": 26157, + "reve": 26158, + "to;\\n ": 26159, + ", bytes calldata data": 26160, + "unsuccessful ": 26161, + "unpause() internal virtual whenPaused ": 26162, + "functions, and ": 26163, + "address ": 26164, + ");\\n // The ": 26165, + "\\n let ": 26166, + "is required to ": 26167, + "\\n\\n constructor(": 26168, + "etch": 26169, + ") {\\r\\n ": 26170, + "sump": 26171, + "or when ": 26172, + "transfer.selector, to, value": 26173, + "lose": 26174, + "TransferFee": 26175, + "\\n * mechanism that can be triggered by an authorized account": 26176, + "\\n * members except through off-chain means by accessing the contract event log": 26177, + "but": 26178, + "in bytes32": 26179, + "for efficiency ": 26180, + "if `account` is ": 26181, + "ura": 26182, + "..223": 26183, + "msgSender == ": 26184, + "as little ": 26185, + "balance, and ": 26186, + "beacon ": 26187, + "cle ": 26188, + ") public pure returns (": 26189, + "maxTx": 26190, + "maxHoldingAmount": 26191, + "(uint256 assets": 26192, + "numMinted": 26193, + "operator == ": 26194, + "this is not ": 26195, + "swap the ": 26196, + "Requirements:\\r\\n * - ": 26197, + "interface/": 26198, + "bool result": 26199, + "Buil": 26200, + "owns it": 26201, + "balanceOf(account": 26202, + "role), 32": 26203, + "prefer": 26204, + "Intended to be ": 26205, + "plan": 26206, + "Total: ": 26207, + ";\\n emit ": 26208, + "; j": 26209, + "\\n */\\n function _check": 26210, + "\\n// This ": 26211, + "s, avoid-call-value": 26212, + ".\\n * It is ": 26213, + "_SECON": 26214, + "must be paused.\\n */\\n function _": 26215, + "must be paused.\\n */\\n modifier ": 26216, + ":::": 26217, + "][_spender": 26218, + ");\\n }\\n\\n // =============================================================\\n // ": 26219, + "AdminACL": 26220, + "Staker": 26221, + "E_T": 26222, + "we need to ": 26223, + ",\\r\\n string memory ": 26224, + "/EIP712": 26225, + "Checks": 26226, + "Pods": 26227, + "------------------------": 26228, + "Defin": 26229, + "bool,uint": 26230, + "total amount of ": 26231, + "emit Transfer(address(0), ": 26232, + "defined by `": 26233, + "_msgSender());\\n }\\n}\\n\"": 26234, + "BaseTokenURI": 26235, + ") internal pure returns (uint256) {\\n // ": 26236, + "deleted ": 26237, + "BlockNumber": 26238, + "message including the ": 26239, + "does not return ": 26240, + "Limit\"": 26241, + "Emitted when a ": 26242, + ",\\n ERC721": 26243, + "if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit ": 26244, + "values.\\n // The ": 26245, + "you need to ": 26246, + ") internal {\\n // ": 26247, + "revert(\\n string(\\n abi.encodePacked(": 26248, + ");\\n require(signer": 26249, + ".sol\\\";\\n\\n/// @title ": 26250, + "compound": 26251, + ";\\r\\n bool public ": 26252, + "price of the ": 26253, + "-= 1; ": 26254, + "Genius": 26255, + "enumeration": 26256, + "author: ": 26257, + "(\\n address target,\\n bool ": 26258, + "(address target, bytes memory data) internal returns (bytes memory": 26259, + "UNIS": 26260, + "to\\n * the functions of your contract. Note that they will not be pausable ": 26261, + "saleConfig": 26262, + "the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied ": 26263, + "_ownerships[tokenId": 26264, + ");\\n }\\n}\\n\"": 26265, + "\\n * using ": 26266, + "_packedOwnershipOf(": 26267, + "\\t\\t\\t": 26268, + "corresponding ": 26269, + "EIP-20 ": 26270, + "that can be set ": 26271, + "returns(bool)": 26272, + ".\\n mstore8(": 26273, + "),\\n \\\"": 26274, + "{\\n /**\\n * @dev Returns the ": 26275, + "membership": 26276, + "excludeFromFees(": 26277, + "160..223": 26278, + "CESS": 26279, + " Limit ": 26280, + "Wrapper": 26281, + "desired": 26282, + "2, shl(": 26283, + "firstTokenId": 26284, + "from `s": 26285, + "avoiding ": 26286, + "amplification ": 26287, + "module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied ": 26288, + "_paused;\\n\\n /**\\n * @dev Initializes the contract ": 26289, + "swapBack(": 26290, + "AutoLiquify": 26291, + "isApprovedForAll(owner, _msgSenderERC721A())": 26292, + "Spac": 26293, + "participant": 26294, + "potentially ": 26295, + "`,\\n // ": 26296, + "by\\n * simply including this module, only once the modifiers are put in plac": 26297, + "ERC721Metadata.": 26298, + "Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer": 26299, + "). No ": 26300, + ".\\n *\\n * Requirements:\\n *\\n * - The contract must not be ": 26301, + ".\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n modifier ": 26302, + "Emits a {Transfer} event ": 26303, + "withdrawableReward": 26304, + "history": 26305, + ", created from `s": 26306, + "contract is paused.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n modifier ": 26307, + "\\n * {AccessControlEnumerable": 26308, + "responsible ": 26309, + "imilar to `": 26310, + "// File @openzeppelin/contracts/": 26311, + "; ++i) {\\n ": 26312, + "log_2, shl(": 26313, + "administrator": 26314, + "3F))": 26315, + "127, mul(": 26316, + "toHexString(uint256(role), 32": 26317, + "Half": 26318, + "token\\n * by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ": 26319, + "amount exceeds balance\\\");\\n _totalSupply = _totalSupply.sub(amount);\\n emit Transfer": 26320, + " for a specific ": 26321, + "change the starting token ID": 26322, + "=-=-=-=-=-=-=-=-": 26323, + "an account has a ": 26324, + "r := shr(127, mul(": 26325, + "(uint8 decimals_": 26326, + "Depositor": 26327, + "Returns an Ethereum Signed Message, created from `s": 26328, + "token/ERC20/ERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general ": 26329, + ";\\n uint8 private _decimals": 26330, + "Store the length": 26331, + "currentDelegate, delegatee": 26332, + "\"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\"": 26333, + "ERC721Enumerable: global ": 26334, + ") / _ONE;\\n _expTable": 26335, + "Global": 26336, + "rocketStorage": 26337, + "ds-test/src/\"": 26338, + "pause() internal virtual whenNotPaused {\\n _paused = true;\\n emit Paused(": 26339, + "state.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n function _": 26340, + "state.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n function _": 26341, + "`account`.\\n */\\n event Unpaused(address account": 26342, + "`account`.\\n */\\n event Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by ": 26343, + "hardh": 26344, + "paused(), \\\"Pausable: paused": 26345, + ",\\n bool[] calldata ": 26346, + "cript": 26347, + "log_2 := or(": 26348, + "unitBalance": 26349, + ".\\n *\\n * This module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied ": 26350, + "address[] memory path = new address[](2);\\n ": 26351, + "isApprovedForAll(owner, spender)": 26352, + ";\\n require(c / a == b, \\\"SafeMath: multiplication overflow\\\");\\n return c": 26353, + "let f := shr(128": 26354, + "_msgSender());\\n }\\n\\n /**\\n * @dev Returns to normal ": 26355, + ";\\n }\\n\\n /**\\n * @dev Modifier to make a function callable only when the contract is not paused": 26356, + "lower than 0.5%\"": 26357, + "liquidator": 26358, + "We will need ": 26359, + "inline assembly": 26360, + "across all ": 26361, + "address(token).": 26362, + "159] ": 26363, + "maturity": 26364, + "bytes32 structHash = ": 26365, + ".\\n if (address(OPERATOR_FILTER_REGISTRY).code.length": 26366, + " = (_expTable": 26367, + "32-byte word al": 26368, + "Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version ": 26369, + "(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval": 26370, + "let length := sub(": 26371, + "that doesn't allow enumerating role": 26372, + "---------------------------------------------------------------------------------------------------------------//\\n // ": 26373, + ");\\n\\n bool private _paused;\\n\\n /**\\n * @dev Initializes the contract ": 26374, + "0._\\n */\\n function ": 26375, + "maximum of 78 digits. ": 26376, + "_balances[account] = _balances[account].sub(amount, \\\"ERC20: burn amount exceeds balance\\\");\\n _totalSupply = _totalSupply.sub(amount);\\n emit Transfer": 26377, + "sequence of ": 26378, + "_toString(tokenId))) : ": 26379, + "address owner,\\r\\n address spender": 26380, + "replay attack": 26381, + "ensure(deadline": 26382, + "(\\r\\n address sender,\\r\\n address recipient,\\r\\n uint256 amount\\r\\n ": 26383, + "{\\n // Ensure the sender is only the owner or contract itself.\\n _onlyOwnerOrSelf();\\n\\n // ": 26384, + "bytes memory returndata = ": 26385, + "Update the free memory pointer to allocate": 26386, + "External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControl": 26387, + "Triggers stopped state.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n function _": 26388, + "s. Some\\n * applications may benefit from on-chain enumerability, for those cases see": 26389, + "pause is triggered by `account`.\\n */\\n event Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by ": 26390, + "Keep dividing `temp": 26391, + "to keep the free memory pointer 32-byte word al": 26392, + "Contract module which allows children to implement an emergency stop\\n * mechanism that can be triggered by an authorized account": 26393, + "unpause() internal virtual whenPaused {\\n _paused = false;\\n emit Unpaused(": 26394, + "\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see": 26395, + "message including the required role": 26396, + "if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender()": 26397, + "revert(\\n string(\\n abi.encodePacked(\\n \\\"": 26398, + "UNISWAP": 26399, + "to\\n * the functions of your contract. Note that they will not be pausable by\\n * simply including this module, only once the modifiers are put in plac": 26400, + "_packedOwnershipOf(index": 26401, + "160..223] `": 26402, + ".\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n modifier whenNotPaused(": 26403, + "contract is paused.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n modifier whenPaused(": 26404, + "\\n * {AccessControlEnumerable}.\\n *\\n * ": 26405, + "r := shr(127, mul(r, r": 26406, + "pause() internal virtual whenNotPaused {\\n _paused = true;\\n emit Paused(_msgSender());\\n }\\n\\n /**\\n * @dev Returns to normal ": 26407, + "state.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n function _unpause() internal virtual whenPaused {\\n _paused = false;\\n emit Unpaused(": 26408, + "log_2 := or(log_2, shl(": 26409, + ".\\n *\\n * This module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\\n * the functions of your contract. Note that they will not be pausable by\\n * simply including this module, only once the modifiers are put in plac": 26410, + "let f := shr(128, r": 26411, + ";\\n }\\n\\n /**\\n * @dev Modifier to make a function callable only when the contract is not paused.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n modifier whenNotPaused(": 26412, + ");\\n\\n bool private _paused;\\n\\n /**\\n * @dev Initializes the contract in unpaused state": 26413, + "maximum of 78 digits. Total: ": 26414, + "Triggers stopped state.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n function _pause() internal virtual whenNotPaused {\\n _paused = true;\\n emit Paused(_msgSender());\\n }\\n\\n /**\\n * @dev Returns to normal ": 26415, + "pause is triggered by `account`.\\n */\\n event Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by `account`.\\n */\\n event Unpaused(address account": 26416, + "Keep dividing `temp` until ": 26417, + "Contract module which allows children to implement an emergency stop\\n * mechanism that can be triggered by an authorized account.\\n *\\n * This module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\\n * the functions of your contract. Note that they will not be pausable by\\n * simply including this module, only once the modifiers are put in plac": 26418, + "\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * ": 26419, + "Triggers stopped state.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n function _pause() internal virtual whenNotPaused {\\n _paused = true;\\n emit Paused(_msgSender());\\n }\\n\\n /**\\n * @dev Returns to normal state.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n function _unpause() internal virtual whenPaused {\\n _paused = false;\\n emit Unpaused(": 26420, + " at ": 26421, + " with ": 26422, + " exceeds the ": 26423, + "\"!": 26424, + "'<": 26425, + "-- ": 26426, + "-test": 26427, + ".\\\");\\n require(": 26428, + ".\\n\\n struct ": 26429, + "/Context": 26430, + "0,\\n ": 26431, + "1E": 26432, + "5%": 26433, + ";\\n * }\\n * ```\\n *\\n * ": 26434, + "AIM": 26435, + "A.selector ^ ": 26436, + "B.selector ^ ": 26437, + "Cvx": 26438, + "GO": 26439, + "Goo": 26440, + "How ": 26441, + "Met": 26442, + "Mess": 26443, + "NX": 26444, + "RPC ": 26445, + "] `": 26446, + "_1": 26447, + "_i": 26448, + "_nextTokenId": 26449, + "_OUT": 26450, + "`_currentIndex - ": 26451, + "bps": 26452, + "c4": 26453, + "e7": 26454, + "find": 26455, + "gov": 26456, + "same as ": 26457, + "sniper": 26458, + "z := ": 26459, + "{_setupDecimals": 26460, + " //\\n//": 26461, + "\\ninterface ": 26462, + "ed.\\n *\\n * ": 26463, + "acing\\n // ": 26464, + ") calls.": 26465, + "at}.": 26466, + "entinel": 26467, + "istic": 26468, + "emission": 26469, + "// Decl": 26470, + "uint256 lastIndex = ": 26471, + "from,\\n ": 26472, + "Refe": 26473, + ".script": 26474, + "value.": 26475, + " = msg.sender": 26476, + "Fees ": 26477, + "FeeRate": 26478, + ");\\n } else {": 26479, + "in that ": 26480, + "in constant ": 26481, + "in storage to ": 26482, + "in O(1), ": 26483, + "for ownerOf(tokenId": 26484, + ". (": 26485, + ". For example": 26486, + "ERC721, ": 26487, + "and 3 ": 26488, + "and decrease ": 26489, + "uration ": 26490, + "totalTokens > ": 26491, + "private my": 26492, + "private functions, and ": 26493, + "..191": 26494, + "..127": 26495, + "aby": 26496, + "mintCompli": 26497, + ") external onlyRole(": 26498, + "value of the ": 26499, + "that fit": 26500, + "that means the ": 26501, + "if (curr < _currentIndex": 26502, + "pose": 26503, + "acked ": 26504, + ") public returns (": 26505, + "Exampl": 26506, + "a snapshot ": 26507, + "(uint256 packed": 26508, + "OwnershipAt(uint256 index": 26509, + "This modifies the ": 26510, + ", packed ": 26511, + "code\\n // ": 26512, + "length-1": 26513, + "with as little ": 26514, + "are writing ": 26515, + "e {\\n * ": 26516, + "totalSupply() public view override returns (": 26517, + "Emergen": 26518, + "Bud": 26519, + "Received ": 26520, + "balanceOf(msg.sender": 26521, + "h from the ": 26522, + "] = packed": 26523, + ") external view returns (uint);\\n\\n function ": 26524, + "\\\");\\n // ": 26525, + "safe96(": 26526, + "decimals}, ": 26527, + "\\n // in bytes32": 26528, + " the `": 26529, + "set state variable": 26530, + "0, Errors.": 26531, + ":= aux": 26532, + "0 as a s": 26533, + "64 bits for `": 26534, + "64..127": 26535, + "].value = ": 26536, + "ownership.startTimestamp = uint64(": 26537, + ");\\n }\\n ": 26538, + "Pausable is Context ": 26539, + ", and checked for ": 26540, + "\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable": 26541, + "all indexes": 26542, + "}\\n }\\n\\n ": 26543, + "use 0 as a s": 26544, + "manual ": 26545, + "ERC721A(\\\"": 26546, + "128..191": 26547, + ";\\r\\n\\r\\n /**\\r\\n * @dev ": 26548, + " and decrement the ": 26549, + "block.timestamp - ": 26550, + "Stage ": 26551, + "pools": 26552, + "s are constants ": 26553, + ");\\r\\n _": 26554, + "we can only ": 26555, + "we swap the ": 26556, + "1 / ": 26557, + "Role(role, ": 26558, + "implementations (such as ": 26559, + "library methods": 26560, + "indicates ": 26561, + "To implement ": 26562, + "To delete ": 26563, + "s for types ": 26564, + "code and ": 26565, + "packed += 1": 26566, + "packed -= 1; ": 26567, + ".sol\\\";\\n\\n/**\\n * @dev This ": 26568, + " := and(": 26569, + "It emits ": 26570, + "chainID": 26571, + ", uint wad": 26572, + "typehash": 26573, + "_getImplementation": 26574, + "message sender (": 26575, + "excludeFromLimits": 26576, + "array, as ": 26577, + "array, and then ": 26578, + "from the \\\"main queue": 26579, + "structs ": 26580, + "number of tokens to ": 26581, + "to the index ": 26582, + "ownership slot of tokenId": 26583, + "_balances[account]": 26584, + "variants": 26585, + "ClaimWait": 26586, + "user to ": 26587, + "on the ordering": 26588, + "NFT to ": 26589, + "instead of a ": 26590, + "applications that ": 26591, + "}, initializes ": 26592, + " IERC721": 26593, + "time\\n * (": 26594, + "ed, we ": 26595, + "compare the ": 26596, + "slot where the ": 26597, + "to a value ": 26598, + "s.length), s": 26599, + "If the ownership slot of tokenId": 26600, + "swapTokensForEth(": 26601, + "delete is": 26602, + "delete with the last ": 26603, + ", 1)\\n // ": 26604, + "\"// SPDX-License-Identifier: MIT\\npragma solidity >=": 26605, + "txType": 26606, + "use {_setupDecimals": 26607, + "initiator ": 26608, + "_ownershipAt(uint256 index": 26609, + "increment and decrement the ": 26610, + "uses private functions, and ": 26611, + "ght to ": 26612, + "permissions ": 26613, + "excludeFromMaxTransaction(address(": 26614, + "Previou": 26615, + "224] `": 26616, + "Mask of an ": 26617, + "implementation uses private functions, and ": 26618, + "Authent": 26619, + "Defaults to ": 26620, + "ownership.burned = ": 26621, + "default value of 18": 26622, + "// The interface ID": 26623, + "described in {": 26624, + "[from] += ": 26625, + "_msgSenderERC721A() internal view virtual returns (": 26626, + "relax": 26627, + "Initializes the ownership slot ": 26628, + " is not explicitly ": 26629, + ", we write it ": 26630, + "enumerated in ": 26631, + "\\n override\\n returns (": 26632, + "set, that means the ": 26633, + "Additional ": 26634, + "element of the ": 26635, + "bptTotalSupply": 26636, + "number burned": 26637, + ")\\n // To delete ": 26638, + ", uint256 index) private view returns (": 26639, + "isContract(target), \\\"Address: call to non-contract": 26640, + "in packed address data ": 26641, + " = 225": 26642, + "mask of the ": 26643, + "icking a ": 26644, + " is Context, IAccessControl": 26645, + "() external pure returns (bytes32": 26646, + "192..255] `": 26647, + ";\\n }\\n\\n function _msgData() internal view virtual returns (bytes memory": 26648, + "_approve(_msgSender(), spender, amount": 26649, + ");\\n\\n // Delete the ": 26650, + "from `packed": 26651, + "prevOwnershipPacked)) != ": 26652, + "types with as little ": 26653, + "Update the index for the ": 26654, + "`index` for efficiency ": 26655, + " of the `burned` ": 26656, + "type with\\n // ": 26657, + "for {decimals}, ": 26658, + "_packedAddressData[to]": 26659, + "_packedAddressData[from]": 26660, + ":\\n *\\n * - ": 26661, + "ownership.addr = address(uint160(": 26662, + "{decimals} with": 26663, + "removed, and checked for ": 26664, + "representing the first 4": 26665, + "O(1)).": 26666, + "Pos++]": 26667, + "just wrapp": 26668, + "We can directly compare the ": 26669, + "We can directly increment and decrement the ": 26670, + "uint24 previousExtraData": 26671, + "guarantees are made ": 26672, + "Position of the ": 26673, + "total number of tokens burned": 26674, + "stored at length-1": 26675, + ").\\n */\\n function _contains(": 26676, + ").\\n */\\n function _length(": 26677, + "this library for multiple ": 26678, + "TX Limit ": 26679, + "+= 1`.": 26680, + "BITMASK_ADDRESS_DATA_ENTRY = (1 << ": 26681, + "BITPOS_START_TIMESTAMP = 160": 26682, + "BITPOS_NUMBER_MINTED) ": 26683, + "BITPOS_NUMBER_MINTED = 64": 26684, + "BITPOS_NUMBER_BURNED;": 26685, + "BITPOS_NUMBER_BURNED) ": 26686, + "BITPOS_NUMBER_BURNED) - 1": 26687, + "BITPOS_NUMBER_BURNED = 128": 26688, + "(bool success, ) = recipient.call{ value: amount ": 26689, + "` array, plus ": 26690, + "address(uint160(prevOwnershipPacked)) != ": 26691, + "\\n /// ": 26692, + "goo ": 26693, + "uint _amount": 26694, + ") public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * ": 26695, + "select a different value for {decimals}, ": 26696, + "es = new ": 26697, + "BITMASK_NEXT_INITIALIZED = 1 << ": 26698, + "] `numberBurned": 26699, + "+1) calls.": 26700, + "+1 is not explicitly ": 26701, + "toDeleteIndex] = ": 26702, + " = (1 << 192": 26703, + "Set the slot of tokenId": 26704, + "Move the last ": 26705, + "s in the interface": 26706, + "s of a generic ": 26707, + " = 5000": 26708, + "initializer function ": 26709, + "63] ": 26710, + "loaned": 26711, + "collected": 26712, + "BITPOS_AUX = 192": 26713, + "&&\\n !": 26714, + "BITPOS_NEXT_INITIALIZED = 225": 26715, + "WrappedToken": 26716, + "entry in packed ": 26717, + "BITMASK_BURNED = 1 << ": 26718, + "= _totalSupply.add(amount);\\n _balances[account] = _balances[account].add(amount);\\n emit Transfer": 26719, + "function selectors in the interface": 26720, + " value\\n ": 26721, + "ERC165 interface ID for ERC721Metadata.": 26722, + "maintain correctness for ownerOf(tokenId": 26723, + "If you are writing ": 26724, + "_startTokenId()` ": 26725, + "packed ownership data ": 26726, + "This is equivalent to `packed -= 1; ": 26727, + "|| _isExcludedFromFees[to]": 26728, + "Link": 26729, + "225] `": 26730, + "uint256) _indexes": 26731, + "token\\n * by either {approve} or {setApprovalForAll}.\\n * - ": 26732, + ") external;\\r\\n\\r\\n function ": 26733, + "order of the array, as ": 26734, + "explicitly in storage to ": 26735, + "multiplying by ": 26736, + "_operatorApprovals[_msgSenderERC721A()": 26737, + "stored\\n ": 26738, + "_AUX_COMPLEMENT = (1 << 192": 26739, + "defaults to `msg.sender": 26740, + "GSN compatible ": 26741, + "excludeMultipleAccountsFromFees": 26742, + "Instead": 26743, + "index for the deleted ": 26744, + "ILL ": 26745, + "(\\n bytes32 hash,\\n bytes32 r,\\n bytes32 vs\\n ) internal pure returns (address, RecoverError) {\\n bytes32 ": 26746, + "(\\n bytes32 hash,\\n bytes32 r,\\n bytes32 vs\\n ) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, r, vs);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover": 26747, + "except the 64 bits for `": 26748, + "(\\n bytes32 hash,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, v, r, s);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Message, created from a `hash`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash": 26749, + "(\\n bytes32 hash,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal pure returns (address, RecoverError) {\\n // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\\n // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\\n //\\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\\n // these malleable signatures as well.\\n if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\\n return (address(0), RecoverError.InvalidSignatureS": 26750, + "decrement the balance, and ": 26751, + "Delete the slot where the ": 26752, + "// ERC165 interface ID for ERC165": 26753, + " = address(uint160(prevOwnershipPacked": 26754, + "i.functionA.selector ^ ": 26755, + "i.functionB.selector ^ ": 26756, + "auxCasted := aux": 26757, + "; // Updates: `balance -= 1": 26758, + "; // Updates: `balance += 1`.": 26759, + ") are just wrapp": 26760, + "remove the last ": 26761, + "increment the number burned": 26762, + "during contract creation": 26763, + "contracts, you need to ": 26764, + "present.\\n */\\n function _remove(": 26765, + "$$ | ": 26766, + "specialization": 26767, + "toInt256Safe": 26768, + "in {at}.": 26769, + ".\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals": 26770, + "block.timestamp <= deadline": 26771, + "means that we can only ": 26772, + ";\\n *\\n * // Decl": 26773, + "&&\\r\\n !": 26774, + "_ownerOf[id": 26775, + "`bytes4(i.functionA.selector ^ ": 26776, + ".sol)\\r\\n\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\n/**\\r\\n * @dev ": 26777, + "(\\n address sender,\\n address recipient,\\n uint256 amount\\n ) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\"": 26778, + "filter ": 26779, + "in terms of a generic ": 26780, + ":= keccak256(0x00, 0x": 26781, + "\"contracts/pendle/contracts/": 26782, + "] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of ": 26783, + ").\\n // This modifies the ": 26784, + "noted in {at}.": 26785, + "properties:\\n *\\n * - ": 26786, + "home/dave/": 26787, + "upscaleArray(": 26788, + "existence in constant ": 26789, + "There is no ": 26790, + "interfaceId == 0x80ac58cd || // ERC165 interface ID for ": 26791, + "interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata.": 26792, + "_packedOwnerships[tokenId] ": 26793, + "1 to all indexes": 26794, + "86400": 26795, + "EIP 712 ": 26796, + "minted at `index` for efficiency ": 26797, + ".\\n // This means that we can only ": 26798, + "\\n // and use 0 as a s": 26799, + " - 1;\\n uint256 lastIndex = ": 26800, + "tryRecover(hash, v, r, s);\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\\n *\\n * _Available since v4.2._\\n */\\n function recover(\\n bytes32 hash,\\n bytes32 r,\\n bytes32 vs\\n ) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, r, vs);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover": 26801, + ");\\n }\\n\\n // If the signature is valid (and not malleable), return the signer address\\n address signer = ecrecover(hash, v, r, s);\\n if (signer == address(0)) {\\n return (address(0), RecoverError.InvalidSignature);\\n }\\n\\n return (signer, RecoverError.NoError);\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n */\\n function recover(\\n bytes32 hash,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, v, r, s);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Message, created from a `hash`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash": 26802, + ");\\n } else {\\n return (address(0), RecoverError.InvalidSignatureLength);\\n }\\n }\\n\\n /**\\n * @dev Returns the address that signed a hashed message (`hash`) with\\n * `signature`. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it.\\n */\\n function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, signature);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\\n *\\n * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover(\\n bytes32 hash,\\n bytes32 r,\\n bytes32 vs\\n ) internal pure returns (address, RecoverError) {\\n bytes32 ": 26803, + "\\n\\n uint256 toDeleteIndex": 26804, + "are a set state variable": 26805, + "slot\\n delete ": 26806, + "{\\n /**\\n * @dev Emitted when the pause is triggered by `account`.\\n */\\n event Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by `account`.\\n */\\n event Unpaused(address account": 26807, + "added, removed, and checked for ": 26808, + "sometimes called as ": 26809, + "have the following properties:\\n *\\n * - ": 26810, + "address payable) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes memory": 26811, + "O(n). No ": 26812, + "];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev ": 26813, + ", but we add 1 to all indexes": 26814, + "+1 explicitly in storage to ": 26815, + "// Storage of ": 26816, + "_packedOwnerships[index] = _packedOwnershipOf(index": 26817, + "address is zero, packed ": 26818, + "repetition as possible": 26819, + "require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721.ownerOf(tokenId);\\n return (spender == owner || ": 26820, + "// Add the library methods": 26821, + "zero.\\n temp := div(temp, 10": 26822, + "user-facing\\n // ": 26823, + "_balances[sender] = _balances[sender].sub(amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[recipient] = _balances[recipient].add(amount);\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` ": 26824, + "32 bytes leftwards to make room for the length.\\n ": 26825, + "Cache the end of the memory to calculate the length later.\\n let end := ": 26826, + "159] `addr": 26827, + "Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role": 26828, + "160..223] `startTimestamp": 26829, + "Contract module which allows children to implement an emergency stop\\n * mechanism that can be triggered by an authorized account.\\n *\\n * This module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\\n * the functions of your contract. Note that they will not be pausable by\\n * simply including this module, only once the modifiers are put in place.\\n */\\nabstract contract ": 26830, + ";\\n * }\\n * ```\\n *\\n * As of ": 26831, + "] `numberMinted": 26832, + "`_currentIndex - _startTokenId()` ": 26833, + "entinel value\\n ": 26834, + "in O(1), we swap the ": 26835, + "that fit\\n // in bytes32": 26836, + "Example {\\n * ": 26837, + "code\\n // repetition as possible": 26838, + "64..127] `numberMinted": 26839, + "128..191] `numberBurned": 26840, + "s are constants representing the first 4": 26841, + "To implement this library for multiple ": 26842, + "s for types that fit\\n // in bytes32": 26843, + "message sender (defaults to `msg.sender": 26844, + "array, and then remove the last ": 26845, + "to the index where the ": 26846, + "on the ordering.\\n *\\n * ": 26847, + "}, initializes {decimals} with": 26848, + "time\\n * (O(1)).": 26849, + "If the ownership slot of tokenId+1 is not explicitly ": 26850, + "initiator owns it": 26851, + "224] `burned": 26852, + "Mask of an entry in packed ": 26853, + "implementation uses private functions, and user-facing\\n // ": 26854, + "// The interface IDs are constants representing the first 4": 26855, + "Initializes the ownership slot minted at `index` for efficiency ": 26856, + ", we write it in terms of a generic ": 26857, + "enumerated in O(n). No ": 26858, + "in packed address data except the 64 bits for `": 26859, + "192..255] `aux": 26860, + ");\\n\\n // Delete the index for the deleted ": 26861, + "types with as little code\\n // repetition as possible": 26862, + "Update the index for the moved ": 26863, + "type with\\n // bytes32 ": 26864, + "_packedAddressData[to]; // Updates: `balance += 1`.": 26865, + "_packedAddressData[from]; // Updates: `balance -= 1": 26866, + "ownership.addr = address(uint160(packed": 26867, + "We can directly compare the packed ": 26868, + "We can directly increment and decrement the balances": 26869, + "guarantees are made on the ordering.\\n *\\n * ": 26870, + "stored at length-1, but we add 1 to all indexes": 26871, + "BITMASK_ADDRESS_DATA_ENTRY = (1 << 64": 26872, + "` array, plus 1": 26873, + "select a different value for {decimals}, use {_setupDecimals": 26874, + "BITMASK_NEXT_INITIALIZED = 1 << 225": 26875, + "Set the slot of tokenId+1 explicitly in storage to ": 26876, + "63] `balance": 26877, + "BITMASK_BURNED = 1 << 224": 26878, + "maintain correctness for ownerOf(tokenId+1) calls.": 26879, + "If you are writing GSN compatible ": 26880, + "This is equivalent to `packed -= 1; packed += 1": 26881, + "225] `nextInitialized": 26882, + "order of the array, as noted in {at}.": 26883, + "decrement the balance, and increment the number burned": 26884, + "Delete the slot where the moved ": 26885, + "i.functionB.selector ^ ...": 26886, + ") are just wrappers ": 26887, + "contracts, you need to override this function": 26888, + ";\\n *\\n * // Declare a set state variable": 26889, + "`bytes4(i.functionA.selector ^ i.functionB.selector ^ ...": 26890, + ").\\n // This modifies the order of the array, as noted in {at}.": 26891, + "existence in constant time\\n * (O(1)).": 26892, + ".\\n // This means that we can only create new ": 26893, + "\\n // and use 0 as a sentinel value\\n ": 26894, + "tryRecover(hash, v, r, s);\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\\n *\\n * _Available since v4.2._\\n */\\n function recover(\\n bytes32 hash,\\n bytes32 r,\\n bytes32 vs\\n ) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, r, vs);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover(\\n bytes32 hash,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal pure returns (address, RecoverError) {\\n // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\\n // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\\n //\\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\\n // these malleable signatures as well.\\n if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\\n return (address(0), RecoverError.InvalidSignatureS": 26895, + ");\\n }\\n\\n // If the signature is valid (and not malleable), return the signer address\\n address signer = ecrecover(hash, v, r, s);\\n if (signer == address(0)) {\\n return (address(0), RecoverError.InvalidSignature);\\n }\\n\\n return (signer, RecoverError.NoError);\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n */\\n function recover(\\n bytes32 hash,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, v, r, s);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Message, created from a `hash`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {\\n // 32 is the length in bytes of hash,\\n // enforced by the type signature above\\n return keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n32\\\", hash": 26896, + "{\\n /**\\n * @dev Emitted when the pause is triggered by `account`.\\n */\\n event Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by `account`.\\n */\\n event Unpaused(address account);\\n\\n bool private _paused;\\n\\n /**\\n * @dev Initializes the contract in unpaused state": 26897, + "added, removed, and checked for existence in constant time\\n * (O(1)).": 26898, + "// Add the library methods\\n * using ": 26899, + "Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * ": 26900, + "Example {\\n * // Add the library methods\\n * using ": 26901, + "To implement this library for multiple types with as little code\\n // repetition as possible": 26902, + "s for types that fit\\n // in bytes32.\\n\\n struct ": 26903, + "If the ownership slot of tokenId+1 is not explicitly set, that means the ": 26904, + "implementation uses private functions, and user-facing\\n // implementations (such as ": 26905, + "Initializes the ownership slot minted at `index` for efficiency purposes": 26906, + "enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ": 26907, + "in packed address data except the 64 bits for `aux": 26908, + ");\\n\\n // Delete the index for the deleted slot\\n delete ": 26909, + "stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n ": 26910, + "Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.": 26911, + "If you are writing GSN compatible contracts, you need to override this function": 26912, + ";\\n *\\n * // Declare a set state variable\\n * ": 26913, + ").\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex": 26914, + "added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - ": 26915, + "To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic ": 26916, + "!is": 26917, + "\"Account is already ": 26918, + "\"TX Limit ": 26919, + "' and ": 26920, + "(uniswapV2Pair": 26921, + "(totalSupply() * ": 26922, + ",\\n\\t\\t": 26923, + "1) ": 26924, + "4\\\"": 26925, + "Aa": 26926, + "IR": 26927, + "Imit": 26928, + "IAsset ": 26929, + "IUniswapV3Pool": 26930, + "MGDC": 26931, + "RNG": 26932, + "WILL ": 26933, + "[proof": 26934, + "_fictiveReserve": 26935, + "_matron": 26936, + "`), ": 26937, + "aw": 26938, + "gin ": 26939, + "ota": 26940, + "pi": 26941, + "s))": 26942, + "same": 26943, + "zel": 26944, + "}\\n // ": 26945, + "}\\r\\n ": 26946, + "eral": 26947, + "toUInt": 26948, + "ince\\n // ": 26949, + "ront": 26950, + "uint256);\\n function ": 26951, + "uint256) {\\n return ": 26952, + "returning ": 26953, + "\\n * this ": 26954, + "or\\n * ": 26955, + "functionSelector": 26956, + ") to ": 26957, + ") && ": 26958, + ") % ": 26959, + "address)\\\", p0, p1, p2, p3));\\n\\t}\\n\\n\\tfunction log(bool ": 26960, + "ing, ": 26961, + ");\\n // ": 26962, + "token = ": 26963, + "token's ": 26964, + "ed during ": 26965, + "function call to ": 26966, + "a regular ": 26967, + "` before ": 26968, + "uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId": 26969, + ": must have ": 26970, + ") {\\r\\n": 26971, + "bool)\\\", p0, p1, p2, p3));\\n\\t}\\n\\n\\tfunction log(bool ": 26972, + ".sy": 26973, + "call (i.e. ": 26974, + "ERC20, IERC20": 26975, + ".\\n *\\n * Requirements:\\n * - ": 26976, + "\\n * types": 26977, + "return value: ": 26978, + "return _currentIndex - ": 26979, + ",\\n Rounding rounding": 26980, + "public drop ": 26981, + "if data is ": 26982, + "even": 26983, + ". Note ": 26984, + ". At the ": 26985, + "Initi": 26986, + "ationale": 26987, + "convex": 26988, + "it ourselves": 26989, + "\\n require(": 26990, + "), relax": 26991, + "\\r\\n if (": 26992, + "string)\\\", p0, p1, p2, p3));\\n\\t}\\n\\n\\tfunction log(bool ": 26993, + "ffect ": 26994, + "The contract ": 26995, + "updating": 26996, + ", pay": 26997, + "length,\\n // ": 26998, + "operator,\\n bool approved": 26999, + "}\\n}\\n\\n": 27000, + ").call{value: ": 27001, + "not be false": 27002, + " ": 27003, + " (but ": 27004, + ",\\n uint256 balance": 27005, + "1010": 27006, + "cannot be changed ": 27007, + "tokensToAddLiquidityWith": 27008, + ".\\n */\\n function _toString": 27009, + "Unit": 27010, + "See {ERC20-": 27011, + "_approve(account, ": 27012, + "abi.encode ": 27013, + "))\\r\\n ": 27014, + "constructor. ": 27015, + "Program": 27016, + "sellTaxes": 27017, + "s to add ": 27018, + "typed ": 27019, + "taxes": 27020, + "out of the ": 27021, + "interface IUniswapV2Router02": 27022, + "Loss": 27023, + ", uint256 amount1": 27024, + "non-fungible ": 27025, + "readable ": 27026, + "WhiteList": 27027, + "(address owner, uint256 ": 27028, + "Admin(address ": 27029, + "pools ": 27030, + "two values": 27031, + "uint168": 27032, + "ing the requirement": 27033, + "gas error": 27034, + "Accept": 27035, + "\\n *\\n * @param ": 27036, + "version` is ": 27037, + "Solidity high": 27038, + "#####": 27039, + " = _get": 27040, + "already": 27041, + "mechanism, s": 27042, + "decreas": 27043, + "` operator.\\n *\\n * Requirements:\\n * - ": 27044, + "places": 27045, + "e. The ": 27046, + ", it can be ": 27047, + "payable _": 27048, + "registrant's ": 27049, + "via `": 27050, + "duration ": 27051, + "during the ": 27052, + "limited ": 27053, + "\\n /// @param tick": 27054, + "██████": 27055, + "on the return value: ": 27056, + "an address which ": 27057, + "Many": 27058, + "a contract), relax": 27059, + "revert(0, ": 27060, + "}, as ": 27061, + "}.\\n *\\n * All three of these values are immutable: they can only be set once during\\n * construction": 27062, + "permit(address owner, address spender": 27063, + "_FROM": 27064, + "below the ": 27065, + "Role(bytes32 role) {\\n _check": 27066, + "Converts a ": 27067, + "configID": 27068, + "over ``owner``'s ": 27069, + "max transaction ": 27070, + "locked_stake": 27071, + "(address account, uint256 amount) internal virtual {\\r\\n require(": 27072, + "value is optional": 27073, + "tokenIdsLength": 27074, + ", it must not be false": 27075, + "size checking ": 27076, + "Ratio ": 27077, + "allowance(address owner, address spender) external view returns (uint256": 27078, + "math/SafeCast": 27079, + "specific role. ": 27080, + "\\\");\\r\\n _": 27081, + "\\\");\\r\\n unchecked {\\r\\n ": 27082, + ";\\n\\n // Check ": 27083, + ";\\n uint256 internal constant UN": 27084, + ");\\n if (to.code.length != 0": 27085, + "{IERC20-approve}, the ": 27086, + "_addPauser": 27087, + "CreatorPaymentAddress": 27088, + "(bool success, bytes memory returndata) = target.call{value: value}": 27089, + "assumed to ": 27090, + "part of the ": 27091, + "DEFAULT_SUBSCRIPTION": 27092, + ";\\r\\n\\r\\n uint256 public ": 27093, + "blockNumber`, ": 27094, + "labor": 27095, + "wallet size": 27096, + ".sol\\\";\\nimport \\\"../extensions/": 27097, + " bits for ": 27098, + "intermediate ": 27099, + "with a standardized ": 27100, + ") {\\r\\n return ": 27101, + "proposal ": 27102, + "Calculate ": 27103, + "\\n\\n // We write the string ": 27104, + "Info storage ": 27105, + "on failure ": 27106, + "\\n ) internal pure returns (uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0))\\n prod0 := mul(x, y)\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1": 27107, + "minimumTokensBeforeSwap": 27108, + "| |_": 27109, + "airdropAddress": 27110, + "BitMap storage ": 27111, + "here, to ": 27112, + "limitsInEffect ": 27113, + "structured ": 27114, + "requency ": 27115, + "numberOfTokens ": 27116, + "_initialized": 27117, + "keccak256(bytes(version": 27118, + "product * ": 27119, + "epochs[": 27120, + "currOwnershipAddr == owner": 27121, + ") {\\n if (returndata.length": 27122, + "(uint16 _dstChainId": 27123, + "low level call here, to ": 27124, + "TokenOwnership memory prevOwnership": 27125, + "t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\\n * instead returning `false` on failure. This behavior is nonetheless\\n * conventional and does not conflict with the expectations of ERC20\\n * applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping(address => uint256) private _balances;\\n\\n mapping(address => mapping(address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The default value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5.05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address to, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _transfer(owner, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``from``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 amount\\n ) public virtual override returns (bool) {\\n address spender = _msgSender();\\n _spendAllowance(from, spender, amount);\\n _transfer(from, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, allowance(owner, spender) + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n uint256 currentAllowance = allowance(owner, spender);\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - subtractedValue);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves `amount` of tokens from `from` to `to`.\\n *\\n * This internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {\\n require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(to != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, amount);\\n\\n uint256 fromBalance = _balances[from];\\n require(fromBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n unchecked {\\n _balances[from] = fromBalance - amount": 27126, + "empty-": 27127, + "isOperatorAllowed(": 27128, + "disabled ": 27129, + "Mutant": 27130, + "Structs": 27131, + ")\\n public\\n view\\n virtual\\n override\\n returns (": 27132, + "InputLength": 27133, + ")\\n }\\n } else {\\n ": 27134, + "increase and decrease ": 27135, + "\"// SPDX-License-Identifier: GPL-3.0-or-later\\n// This program is free software: you can redistribute it and/or modify\\n// it under the terms of the GNU General Public License as published by\\n// the Free Software Foundation, either version 3 of the License, or\\n// (at your option) any later version.\\n\\n// This program is distributed in the hope that it will be useful,\\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\n// GNU General Public License for more details.\\n\\n// You should have received a copy of the GNU General Public License\\n// along with this program. If not, see .\\n\\npragma solidity ^0.7.0;\\n\\nimport \\\"@balancer-labs/v2-": 27136, + "onERC721Received(\\n address operator,\\n address from,\\n uint256 tokenId,\\n bytes calldata data\\n ) external returns (bytes4);\\n}\\n\\n": 27137, + "Gobblers": 27138, + ")\\n\\n // Cache the end of the memory to calculate the length later.\\n let end := ": 27139, + ") | (auxCasted ": 27140, + "for {permit}, as ": 27141, + "_AUX_COMPLEMENT) | (auxCasted ": 27142, + "Booster": 27143, + "_address = _": 27144, + ";\\n\\n mapping (address => mapping (address => uint256": 27145, + "implementing it ourselves": 27146, + "meaning of `": 27147, + "ates a Solidity high": 27148, + "(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, ": 27149, + ".\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator,\\n Rounding rounding": 27150, + ".\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator\\n ) internal pure returns (uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0))\\n prod0 := mul(x, y)\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1": 27151, + "the return value is optional": 27152, + "\"// SPDX-License-Identifier: MIT\\n// ERC721A Contracts v4.2.3\\n// Creator: Chiru Labs\\n\\npragma solidity ^0.8.4;\\n\\nimport './IERC721A": 27153, + ", amountsIn": 27154, + "sqrtRatioAX96": 27155, + "eq(msgSender, ": 27156, + "-level call (i.e. ": 27157, + "owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (": 27158, + "divisorIndex": 27159, + "returned, it must not be false": 27160, + ", ERC165 {\\n struct RoleData {\\n ": 27161, + "permanently ": 27162, + "We need to perform a ": 27163, + ") >> 128;\\n if (absTick & 0x": 27164, + "Revert with a standard message if `account` is ": 27165, + "return data size checking ": 27166, + "(\\n address seaDropImpl,\\n address ": 27167, + " == 0) {\\n return prod0 / denominator;\\n }\\n\\n // Make sure the result is less than 2^256. Also prevents denominator == 0.\\n require(denominator > prod1": 27168, + "Strings.toString(s.length), s": 27169, + "`tokenId` has been\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` has been minted for `to`.\\n * - When `to` is zero, `tokenId` has been burned by `from`.\\n * - `from` and `to` are never both zero.\\n */\\n function _afterTokenTransfers(\\n address from,\\n address to,\\n uint256 startTokenId,\\n uint256 quantity\\n ) internal virtual {}\\n\\n /**\\n * @dev ": 27170, + "no-empty-": 27171, + "out-of-gas error": 27172, + ");\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator)\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder)\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function.\\n uint256 twos = denominator & (~denominator + 1);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1)\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step.\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator,\\n Rounding rounding": 27173, + "decimal representation.\\n */\\n function _toString": 27174, + "curr = tokenId;\\n\\n unchecked {\\n if (_startTokenId() <= curr": 27175, + "clearedWord ": 27176, + "_srcAddress, uint64 _nonce": 27177, + "checks that an account has a ": 27178, + "Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes memory _data\\n ) private returns (bool) {\\n ": 27179, + "Directly ": 27180, + "_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, \\\"ERC20: decreased allowance below zero\\\"));\\n return true;\\n }\\n\\n /**\\n * @dev ": 27181, + ") internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n ": 27182, + "substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub": 27183, + "mintingAllowedAfter": 27184, + ") public view virtual returns (bool) {\\n return _paused": 27185, + "Modifier that checks that an account has a ": 27186, + "keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n\\\", Strings.toString(s.length), s": 27187, + "hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n}\\n\"": 27188, + ";\\n }\\n\\n /**\\n * @dev Returns true if the contract is paused, and false otherwise.\\n */\\n function paused() public view virtual returns (bool) {\\n return _paused": 27189, + "sumption": 27190, + "),\\n \\\" is missing role ": 27191, + "toHexString(uint256(role), 32)\\n )\\n )\\n ": 27192, + "Keep dividing `temp` until zero.\\n temp := div(temp, 10": 27193, + "Triggers stopped state.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n function _pause() internal virtual whenNotPaused {\\n _paused = true;\\n emit Paused(_msgSender());\\n }\\n\\n /**\\n * @dev Returns to normal state.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n function _unpause() internal virtual whenPaused {\\n _paused = false;\\n emit Unpaused(_msgSender());\\n }\\n}\\n\"": 27194, + "Pausable is Context {\\n /**\\n * @dev Emitted when the pause is triggered by `account`.\\n */\\n event Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by `account`.\\n */\\n event Unpaused(address account);\\n\\n bool private _paused;\\n\\n /**\\n * @dev Initializes the contract in unpaused state": 27195, + "\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol\"": 27196, + " is Context, IAccessControl, ERC165 {\\n struct RoleData {\\n ": 27197, + "`bytes4(i.functionA.selector ^ i.functionB.selector ^ ...)`": 27198, + "\"TX Limit Exceeded\"": 27199, + "Imitates a Solidity high": 27200, + "function call to a contract), relax": 27201, + "a regular function call to a contract), relax": 27202, + "if data is returned, it must not be false": 27203, + " (but if data is returned, it must not be false": 27204, + "on the return value: the return value is optional": 27205, + "(address account, uint256 amount) internal virtual {\\r\\n require(account != address(0), \\\"ERC20: ": 27206, + "specific role. Revert": 27207, + ");\\n if (to.code.length != 0)\\n if (!": 27208, + "with a standardized message including the required role": 27209, + "BitMap storage bitmap": 27210, + "low level call here, to bypass ": 27211, + "t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\\n * instead returning `false` on failure. This behavior is nonetheless\\n * conventional and does not conflict with the expectations of ERC20\\n * applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping(address => uint256) private _balances;\\n\\n mapping(address => mapping(address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The default value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5.05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address to, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _transfer(owner, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``from``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 amount\\n ) public virtual override returns (bool) {\\n address spender = _msgSender();\\n _spendAllowance(from, spender, amount);\\n _transfer(from, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, allowance(owner, spender) + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n uint256 currentAllowance = allowance(owner, spender);\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - subtractedValue);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves `amount` of tokens from `from` to `to`.\\n *\\n * This internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {\\n require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(to != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, amount);\\n\\n uint256 fromBalance = _balances[from];\\n require(fromBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n unchecked {\\n _balances[from] = fromBalance - amount;\\n // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\\n // decrementing then incrementing.\\n _balances[to] += amount;\\n }\\n\\n emit Transfer(from, to, amount);\\n\\n _afterTokenTransfer(from, to, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n unchecked {\\n // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\\n _balances[account] += amount;\\n }\\n emit Transfer(address(0), account, amount);\\n\\n _afterTokenTransfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n unchecked {\\n _balances[account] = accountBalance - amount;\\n // Overflow not possible: amount <= accountBalance <= totalSupply.\\n _totalSupply -= amount;\\n }\\n\\n emit Transfer": 27212, + ".\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator\\n ) internal pure returns (uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0))\\n prod0 := mul(x, y)\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1 == 0) {\\n return prod0 / denominator;\\n }\\n\\n // Make sure the result is less than 2^256. Also prevents denominator == 0.\\n require(denominator > prod1": 27213, + "-level call (i.e. a regular function call to a contract), relax": 27214, + "owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n ": 27215, + "We need to perform a low level call here, to bypass ": 27216, + "Revert with a standard message if `account` is missing `role": 27217, + "return data size checking mechanism, s": 27218, + ");\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator)\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder)\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function.\\n uint256 twos = denominator & (~denominator + 1);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1)\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step.\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator,\\n Rounding rounding\\n ": 27219, + "Modifier that checks that an account has a specific role. Revert": 27220, + "Imitates a Solidity high-level call (i.e. a regular function call to a contract), relax": 27221, + "on the return value: the return value is optional (but if data is returned, it must not be false": 27222, + "Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement": 27223, + "\"$": 27224, + "\"D": 27225, + "(uint256[] calldata ": 27226, + ")\\r\\n {\\r\\n ": 27227, + "2981": 27228, + "=\\n ": 27229, + ">0)": 27230, + "Boring": 27231, + "F9": 27232, + "IERC2309": 27233, + "Mon": 27234, + "Of ": 27235, + "Telegram": 27236, + "XEN": 27237, + "_day": 27238, + "_deposit": 27239, + "_interest": 27240, + "e4": 27241, + "f4": 27242, + "mon": 27243, + "n\\u0027": 27244, + "sPer": 27245, + "s\\r\\n * ": 27246, + "wstETH": 27247, + "reven": 27248, + "s {": 27249, + "\\n assembly { ": 27250, + "\\n /// @solidity memory-safe-assembly\\n assembly {\\n ": 27251, + "to prevent": 27252, + "ason": 27253, + "contain the ": 27254, + "sure": 27255, + "eleg": 27256, + "20, ": 27257, + "Reb": 27258, + "Refl": 27259, + "or one ": 27260, + "an already ": 27261, + "ift": 27262, + "Transfers": 27263, + ".\\n */\\n function _msgSenderERC721A() internal view virtual returns (": 27264, + ");\\n ownership.burned = ": 27265, + "--_packedAddressData[from]; // Updates: `balance -= 1": 27266, + "if target ": 27267, + "if the call ": 27268, + ") internal {": 27269, + "not all ": 27270, + "Inv": 27271, + "and each ": 27272, + "and only if the ": 27273, + ".sol\\n\\n": 27274, + "setExtraData": 27275, + "totalBorrow": 27276, + ");\\n\\n if (": 27277, + "s the ownership ": 27278, + "bytes32[](": 27279, + ") external onlyOwner": 27280, + "curr ": 27281, + ") public view ": 27282, + ") public returns (bool) {\\n ": 27283, + ") public onlyOwner {\\n require(": 27284, + "contract was successful, and ": 27285, + "checks ": 27286, + "msg.sender ": 27287, + "current(": 27288, + "currentTokenId": 27289, + "Balances[msg.sender": 27290, + "ailing ": 27291, + "signal ": 27292, + "totalSupply() public view returns (": 27293, + "Returns the next ": 27294, + ", \\\"MerkleProof: invalid multiproof": 27295, + "targeted by the call": 27296, + " ": 27297, + "`toTokenId": 27298, + "Contract.": 27299, + "Balance\"": 27300, + "0.8/": 27301, + "WalletUpdated": 27302, + "/contracts/contracts/": 27303, + ".\\n */\\n function _nextTokenId": 27304, + ".\\n */\\n function _initialize": 27305, + "decimals} to ": 27306, + "hashing and ": 27307, + "transferFrom.selector, ": 27308, + "(_packedOwnerships[": 27309, + "\\n // in": 27310, + "amount overflow": 27311, + ") internal virtual returns (uint256 ": 27312, + "ATED": 27313, + "0 && _": 27314, + "in the range ": 27315, + "using abi.encode ": 27316, + "+= amount": 27317, + ") public virtual returns (bool) {\\r\\n ": 27318, + ");\\n require(": 27319, + ");\\n emit ": 27320, + "supports ": 27321, + "call data (": 27322, + "333": 27323, + "() external view returns (uint);\\n\\n function ": 27324, + "AtTick": 27325, + "ApprovalForAll} event.\\n */\\n function _": 27326, + " and the return ": 27327, + "proofPo": 27328, + "++_packedAddressData[to]; // Updates: `balance += 1`.": 27329, + "es[_from": 27330, + ";\\n }\\n\\n /**\\n * @dev Returns the next token ID to be minted": 27331, + "; // and not ": 27332, + "given by": 27333, + "Depend": 27334, + "());\\n ": 27335, + ";\\n }\\n _balances[to] += ": 27336, + "////////////////////////////////////////////////////////////////": 27337, + ");\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual ": 27338, + "(owner, operator, approved);\\n }\\n\\n /**\\n * @dev ": 27339, + ") / 10000": 27340, + "ter for the ": 27341, + "s\\n * with a standardized message including the required role": 27342, + "\\n // otherwise ": 27343, + "call to smart-": 27344, + "minted with ": 27345, + "packedOwnershipOf(uint256 tokenId": 27346, + "];\\n } else {\\n return ": 27347, + "either by bubbl": 27348, + "bots[": 27349, + "365": 27350, + "000000000000000000": 27351, + "operations that ": 27352, + "revert reason or ": 27353, + "disableInitializer": 27354, + "/// @author: ": 27355, + "_currentIndex;\\n }\\n\\n /**\\n * @dev Returns the ": 27356, + "revert(bytes memory returndata": 27357, + " // ": 27358, + "collection is ": 27359, + ")\\n if (!": 27360, + ")\\n revert(add(32, returndata), returndata_size": 27361, + ";\\r\\n uint256 private ": 27362, + "super._transfer(from, to, amount": 27363, + "(address to, uint256 value": 27364, + "extraData(\\n address from,\\n address to,\\n ": 27365, + "prevOwnership.startTimestamp": 27366, + ") {\\n _paused = false": 27367, + "Calling this function ": 27368, + "`owner` tokens": 27369, + ".sol\\\";\\nimport \\\"../../math/SafeMath": 27370, + "\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ": 27371, + " == 0; // and not ": 27372, + "Desired,\\n uint amountTokenMin,\\n uint amountETHMin,\\n address to,\\n uint deadline": 27373, + ");\\n }\\n }\\n\\n /**\\n * @dev Tool to ": 27374, + "runn": 27375, + "ght = ": 27376, + "{\\n // Look for revert reason and bubble it up if present": 27377, + ".\\n */\\ninterface ERC721A__IERC721Receiver": 27378, + ".\\n * @param data The ": 27379, + "ever change": 27380, + "default one of ": 27381, + ";\\n uint256 internal constant ERC20": 27382, + "costs": 27383, + "`).\\n *\\n * If you are writing GSN compatible contracts, you need to override this function": 27384, + "setupDecimals": 27385, + "assume ": 27386, + " is not a contract": 27387, + "RatioAtTick": 27388, + "\\n\\t * @dev ": 27389, + ");\\n }\\n\\n /**\\n * @notice Update the ": 27390, + "Stake.": 27391, + "\\n *\\n * _Available since v4.1._": 27392, + "root is ": 27393, + "Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n ": 27394, + ".\\n // We will need ": 27395, + ") private view returns (uint256) {\\n uint256 ": 27396, + "`.\\n */\\n function _unpackedOwnership": 27397, + "Slot := ": 27398, + ")\\n // Update the free memory pointer to allocate": 27399, + "KKKKKKKKKKKK": 27400, + "_removeMinter": 27401, + ") internal view returns (bytes memory) {\\n if (success": 27402, + "));\\n ownership.startTimestamp = uint64(": 27403, + "revert (either by bubbl": 27404, + "bitoshis": 27405, + "exemptFrom": 27406, + "exceed the ": 27407, + "PERMIT_TYPEHASH() external pure returns (bytes32": 27408, + "``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature ": 27409, + "execute ": 27410, + "address) {\\n return msg.sender;\\n }\\n\\n /**\\n * @dev ": 27411, + "mapping(address => uint256) private _packedAddressData": 27412, + ");\\n\\n if (address(uint160(prevOwnershipPacked)) != ": 27413, + "it to zero": 27414, + "Requested": 27415, + "`\\n * (": 27416, + ");\\n\\n /**\\n * @notice ": 27417, + "\\n * @param _value ": 27418, + ") internal virtual {\\n uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId": 27419, + "invest": 27420, + "STAK": 27421, + ") private pure returns (TokenOwnership memory ownership": 27422, + "\\n virtual\\n override\\n returns (": 27423, + " == 0) {\\n // only ": 27424, + "{decimals} to a value ": 27425, + "OOOOOOOOOOOO": 27426, + ");\\n}\\n\\ncontract ": 27427, + "ing\\n * the revert reason or ": 27428, + "Getter for the ": 27429, + "was successful and the return ": 27430, + "low level call to smart-": 27431, + ";\\n\\n // The bit position of `aux": 27432, + ";\\n\\n // The bit position of `numberBurned": 27433, + "override returns (bool) {\\n return interfaceId == type(IAccessControl": 27434, + "that it was a ": 27435, + "BITPOS_START_TIMESTAMP);\\n ownership.burned = ": 27436, + "`operator` to operate on ": 27437, + "work incorrectly ": 27438, + "ERC721A__IERC721Receiver(to).onERC721Received": 27439, + ",\\n address[] calldata path,\\n address to,\\n uint256 deadline": 27440, + "let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size": 27441, + "numCheckpoints[": 27442, + "in case of unsuccessful ": 27443, + "Sets {decimals} to a value ": 27444, + "}\\n return returndata;\\n } else {": 27445, + ",\\n uint amountTokenDesired,\\n uint amountTokenMin,\\n uint amountETHMin,\\n address to,\\n uint deadline": 27446, + "encoded using abi.encode ": 27447, + "empty\\n // otherwise ": 27448, + "packed = _packedAddressData[owner": 27449, + "proxy/Proxy": 27450, + "_ownerships[curr]": 27451, + ",\\r\\n address to,\\r\\n uint256 deadline": 27452, + "isOperatorFor": 27453, + "compute the next ": 27454, + "BITPOS_AUX);\\n }\\n\\n /**\\n * ": 27455, + "know that it was a ": 27456, + "index out of bounds\"": 27457, + "until trading is ": 27458, + "verify that a low level call to smart-": 27459, + "// solhint-disable-next-line avoid-low-level-calls, avoid-call-value": 27460, + "data is empty\\n // otherwise ": 27461, + "index]);\\n }\\n\\n /**\\n * @dev ": 27462, + ".\\n //\\n // ": 27463, + ");\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-": 27464, + "verifyCallResultFromTarget(\\n address target,\\n bool ": 27465, + "starts with the ": 27466, + "] = approved;\\n emit ApprovalForAll(owner, operator, approved);\\n }\\n\\n /**\\n * @dev ": 27467, + ".sol\\\";\\r\\n\\r\\ncontract ": 27468, + ".\\n * To change the starting token ID": 27469, + "onlyInitializing": 27470, + "0 ? string(abi.encodePacked(baseURI, _toString(tokenId))) : ": 27471, + "packed = _packedOwnerships[--": 27472, + "reached": 27473, + "all of `owner` tokens": 27474, + "will not expect": 27475, + "prettier-ignore\\n for {": 27476, + "\"erc721a/contracts/ERC721A.sol\"": 27477, + ".\\n */\\n function _totalBurned(": 27478, + "WEIGH": 27479, + "This function should only be called from the constructor. ": 27480, + "join or ": 27481, + ".\\n *\\n * Note: ": 27482, + "`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash(bytes memory s": 27483, + "merging ": 27484, + "][operator] = approved;\\n emit ApprovalForAll(_msgSenderERC721A(), ": 27485, + "branches": 27486, + "starting token ID.\\n * To change the starting token ID": 27487, + "amondCut": 27488, + "paused(), \\\"Pausable: not paused": 27489, + "exponent": 27490, + ") - 1;\\n\\n // The bit position of `startTimestamp": 27491, + ") - 1;\\n\\n // The bit position of `numberMinted": 27492, + ";\\n\\n // The bit mask of the `burned` ": 27493, + ") public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev ": 27494, + ") public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev ": 27495, + "juice-": 27496, + ";\\n\\n // Mask of all 256 bits in packed address data except the 64 bits for `aux": 27497, + "of `tokenId`.\\n */\\n function _packedOwnershipOf(uint256 tokenId": 27498, + ") {\\n (bool success, bytes memory returndata) = target.staticcall": 27499, + "getApproved(tokenId) == spender || ": 27500, + "deposits": 27501, + "token contracts will not expect": 27502, + "was not a contract": 27503, + "sireId": 27504, + ";\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return ": 27505, + "if (to.isContract()) {\\n try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (": 27506, + "JSON RPC ": 27507, + "];\\n uint256 aux": 27508, + "interact with token contracts will not expect": 27509, + "onlyTeamOrOwner": 27510, + "amount + balanceOf(to) <= ": 27511, + "```\\n * contract Example {\\n * // Add the library methods\\n * using ": 27512, + "\\n ) external virtual override ": 27513, + "FEE_DENOMINATOR": 27514, + "at `index`.\\n */\\n function _ownershipAt(uint256 index": 27515, + "address receiver, uint256 royaltyAmount);\\n}\\n\"": 27516, + "uint256) {\\n // Counter underflow is impossible as _burnCounter cannot be incremented\\n // more than `_currentIndex - _startTokenId()` ": 27517, + "does not decrement,\\n // and it is initialized to `": 27518, + ", please override this function.\\n */\\n function _startTokenId() internal view virtual returns (uint256) {\\n return 0;\\n }\\n\\n /**\\n * @dev Returns the next token ID to be minted": 27519, + "_operatorApprovals[owner][operator] = approved;\\n emit ApprovalForAll(owner, operator, approved);\\n }\\n\\n /**\\n * @dev ": 27520, + "tokens,\\n * given ``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature ": 27521, + ");\\n\\n address from = address(uint160(prevOwnershipPacked": 27522, + "// If within bound": 27523, + "balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: ": 27524, + "games": 27525, + "\"@openzeppelin/contracts/access/AccessControl.sol\"": 27526, + "we already know that it was a ": 27527, + "Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the ": 27528, + ".\\n mstore(0x40, m": 27529, + "MinimalSwapInfoPool": 27530, + "other than the default one of ": 27531, + "PROVID": 27532, + "major ": 27533, + ", and may work incorrectly ": 27534, + "APPROVAL OPERATIONS\\n // =============================================================\\n\\n /**\\n * @dev ": 27535, + "call or if target ": 27536, + "\\n */\\n modifier onlyRole(bytes32 role) {\\n _check": 27537, + "Equivalent to `_burn(tokenId, false)`.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n _burn(tokenId, false);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId, bool approvalCheck) internal virtual {\\n uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId": 27538, + "The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n ": 27539, + "sqrt ": 27540, + "token The token targeted by the call": 27541, + ")\\n // Move the pointer 32 bytes leftwards to make room for the length.\\n ": 27542, + "(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(senderBalance ": 27543, + "roles[role].members[account];\\n }\\n\\n /**\\n * @dev ": 27544, + "_packedOwnerships[index] == 0) {\\n ": 27545, + "\\n */\\n function _checkRole(bytes32 role, address account": 27546, + "Returns an Ethereum Signed Message, created from `s`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash(bytes memory s": 27547, + "(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721.ownerOf(tokenId), to, tokenId": 27548, + "(uint256 packed) private pure returns (TokenOwnership memory ownership": 27549, + "applications that interact with token contracts will not expect": 27550, + ", 1)\\n // Write the character to the pointer": 27551, + "Previous ": 27552, + "from `packed`.\\n */\\n function _unpackedOwnership": 27553, + "total number of tokens burned.\\n */\\n function _totalBurned(": 27554, + "BITPOS_START_TIMESTAMP = 160;\\n\\n // The bit mask of the `burned` ": 27555, + "BITPOS_NUMBER_MINTED = 64;\\n\\n // The bit position of `numberBurned": 27556, + "BITPOS_NUMBER_BURNED = 128;\\n\\n // The bit position of `aux": 27557, + "BITPOS_AUX = 192;\\n\\n // Mask of all 256 bits in packed address data except the 64 bits for `aux": 27558, + "BITPOS_NEXT_INITIALIZED = 225;\\n\\n // The bit mask": 27559, + "packed ownership data of `tokenId`.\\n */\\n function _packedOwnershipOf(uint256 tokenId": 27560, + "_operatorApprovals[_msgSenderERC721A()][operator] = approved;\\n emit ApprovalForAll(_msgSenderERC721A(), ": 27561, + "_AUX_COMPLEMENT = (1 << 192) - 1;\\n\\n // The bit position of `startTimestamp": 27562, + "interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721": 27563, + "_packedOwnerships[index] = _packedOwnershipOf(index);\\n }\\n }\\n\\n ": 27564, + "Contract module which allows children to implement an emergency stop\\n * mechanism that can be triggered by an authorized account.\\n *\\n * This module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\\n * the functions of your contract. Note that they will not be pausable by\\n * simply including this module, only once the modifiers are put in place.\\n */\\nabstract contract Pausable is Context {\\n /**\\n * @dev Emitted when the pause is triggered by `account`.\\n */\\n event Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by `account`.\\n */\\n event Unpaused(address account);\\n\\n bool private _paused;\\n\\n /**\\n * @dev Initializes the contract in unpaused state": 27565, + "message sender (defaults to `msg.sender`).\\n *\\n * If you are writing GSN compatible contracts, you need to override this function": 27566, + "ownership.addr = address(uint160(packed));\\n ownership.startTimestamp = uint64(": 27567, + "BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;\\n\\n // The bit position of `numberMinted": 27568, + "Initializes the ownership slot minted at `index` for efficiency purposes.\\n */\\n function _initialize": 27569, + "enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```\\n * contract Example {\\n * // Add the library methods\\n * using ": 27570, + "typed structured ": 27571, + "over ``owner``'s tokens,\\n * given ``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature ": 27572, + ") {\\n if (returndata.length == 0) {\\n // only ": 27573, + ".\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator\\n ) internal pure returns (uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0))\\n prod0 := mul(x, y)\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1 == 0) {\\n return prod0 / denominator;\\n }\\n\\n // Make sure the result is less than 2^256. Also prevents denominator == 0.\\n require(denominator > prod1);\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator)\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder)\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function.\\n uint256 twos = denominator & (~denominator + 1);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1)\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step.\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator,\\n Rounding rounding\\n ": 27574, + "Revert with a standard message if `account` is missing `role`.\\n *\\n * The ": 27575, + "Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role": 27576, + "on the return value: the return value is optional (but if data is returned, it must not be false).": 27577, + "or one of its ": 27578, + ".\\n */\\n function _msgSenderERC721A() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n /**\\n * @dev ": 27579, + "if the call was successful and the return ": 27580, + "contract was successful, and revert (either by bubbl": 27581, + "decimals} to ever change": 27582, + "hashing and sign": 27583, + "transferFrom.selector, from, to, value": 27584, + "call data (encoded using abi.encode ": 27585, + "ApprovalForAll} event.\\n */\\n function _setApprovalForAll": 27586, + ");\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControl": 27587, + "extraData(\\n address from,\\n address to,\\n uint24 previousExtraData": 27588, + " == 0; // and not burned.": 27589, + ");\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a ": 27590, + "{\\n // Look for revert reason and bubble it up if present\\n if (": 27591, + "\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _check": 27592, + ") internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only ": 27593, + "`operator` to operate on all of `owner` tokens": 27594, + "let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n ": 27595, + "in case of unsuccessful call or if target ": 27596, + "Sets {decimals} to a value other than the default one of ": 27597, + "BITPOS_AUX);\\n }\\n\\n /**\\n * Sets the ": 27598, + "data is empty\\n // otherwise we already know that it was a ": 27599, + ");\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbl": 27600, + "verifyCallResultFromTarget(\\n address target,\\n bool success": 27601, + "0 ? string(abi.encodePacked(baseURI, _toString(tokenId))) : ''": 27602, + "This function should only be called from the constructor. Most": 27603, + "juice-contracts-": 27604, + "amount + balanceOf(to) <= maxWallet": 27605, + ", please override this function.\\n */\\n function _startTokenId() internal view virtual returns (uint256) {\\n return 0;\\n }\\n\\n /**\\n * @dev Returns the next token ID to be minted.\\n */\\n function _nextTokenId": 27606, + "balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n ": 27607, + ", and may work incorrectly if it does": 27608, + "Equivalent to `_burn(tokenId, false)`.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n _burn(tokenId, false);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId, bool approvalCheck) internal virtual {\\n uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);\\n\\n address from = address(uint160(prevOwnershipPacked": 27609, + "The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n ": 27610, + "Returns an Ethereum Signed Message, created from `s`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {\\n return ": 27611, + "message sender (defaults to `msg.sender`).\\n *\\n * If you are writing GSN compatible contracts, you need to override this function.\\n */\\n function _msgSenderERC721A() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n /**\\n * @dev ": 27612, + "Initializes the ownership slot minted at `index` for efficiency purposes.\\n */\\n function _initializeOwnershipAt(uint256 index": 27613, + "over ``owner``'s tokens,\\n * given ``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as ": 27614, + "Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The ": 27615, + "if the call was successful and the return data is empty\\n // otherwise we already know that it was a ": 27616, + "decimals} to ever change, and may work incorrectly if it does": 27617, + "call data (encoded using abi.encode or one of its ": 27618, + "in case of unsuccessful call or if target was not a contract": 27619, + "Sets {decimals} to a value other than the default one of 18": 27620, + ");\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or ": 27621, + "if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract": 27622, + " S": 27623, + " let temp := ": 27624, + "\"convex": 27625, + "'swap and pop": 27626, + "').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex": 27627, + "(name": 27628, + "(bytes32[] memory proof": 27629, + ",\\n * ": 27630, + "-= _": 27631, + "-platform": 27632, + "/ ": 27633, + "0\\n // ": 27634, + "1d": 27635, + "4 ": 27636, + ";` ": 27637, + ";\\n // ": 27638, + "B ": 27639, + "F8": 27640, + "IVER": 27641, + "Lat": 27642, + "Land": 27643, + "Me": 27644, + "Next ": 27645, + "QR": 27646, + "S\"": 27647, + "TPL": 27648, + "[ ": 27649, + "_signer": 27650, + "_ZERO_ADDRESS": 27651, + "`\\n * @param ": 27652, + "`\\n mapping(uint256 => uint256) private ": 27653, + "aC": 27654, + "a,\\r\\n uint256 ": 27655, + "eop": 27656, + "filter": 27657, + "lication ": 27658, + "}\\n // ": 27659, + "\\n*": 27660, + "\\npragma solidity 0.8.": 27661, + "\\n ": 27662, + "one {": 27663, + "res.": 27664, + ", address(this), ": 27665, + ", eq(": 27666, + ") 20": 27667, + "addressTo": 27668, + "addressData.": 27669, + "the ID of the ": 27670, + "\\\" to the ": 27671, + "is owed and to whom": 27672, + "asc": 27673, + "from` cannot be the zero address.\\n * - `": 27674, + "of this ": 27675, + ") {\\n\\t\\t": 27676, + "er will ": 27677, + "transfering.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `": 27678, + "an overflow": 27679, + "- An ": 27680, + "Transferable": 27681, + "return no ": 27682, + " = 30": 27683, + ",\\n bytes calldata ": 27684, + "In,\\n uint amount": 27685, + "ERC721(\\\"": 27686, + "and instead ": 27687, + "AmountTo": 27688, + "getTotalFee": 27689, + "getAddressSlot": 27690, + " to your contract": 27691, + "), Errors.": 27692, + "Controll": 27693, + "Address(address _": 27694, + "bytes32(0": 27695, + "true`.\\n // - `nextInitialized` to `": 27696, + "been": 27697, + "maxMint": 27698, + "maxMintAmountPerTx": 27699, + "token URI": 27700, + "minHoldingAmount": 27701, + "the\\n": 27702, + "== 0 || ": 27703, + "currentValue": 27704, + "creation.\\n *\\n * ": 27705, + "burning.\\n // - `burned` to `": 27706, + ");\\n\\n require(\\n ": 27707, + " is IERC721A": 27708, + " is very ": 27709, + "Mints ": 27710, + "(\\n uint256[] memory balances": 27711, + ", \\\"Exceeds the ": 27712, + "swapTimes": 27713, + "illary data for `owner`. (e.g. number of whitelist mint slots used": 27714, + "Liq": 27715, + "bytes32 previousAdmin": 27716, + " back": 27717, + "event for ": 27718, + "] = block.number": 27719, + "\\\");\\n _operatorApprovals[owner][operator] = approved;\\n emit ApprovalForAll(owner, operator, approved);\\n }\\n\\n /**\\n * @dev ": 27720, + "`.\\n function ": 27721, + "notice ": 27722, + "false). ": 27723, + "Math: ": 27724, + "decimals() external pure returns (": 27725, + "uint8((": 27726, + "Unpause": 27727, + "ultane": 27728, + "\\n * @dev Wrappers ": 27729, + "ID for ": 27730, + "start,\\n uint256 ": 27731, + " != address(0), ": 27732, + ".\\n * For ": 27733, + "= _hashTypedDataV4(": 27734, + "uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens": 27735, + "unchecked {\\n ": 27736, + "UniswapV2Library": 27737, + "learn": 27738, + "current computed hash": 27739, + "current element of the ": 27740, + "\"@openzeppelin/contracts/access/IAccessControl": 27741, + "(from, address(this), ": 27742, + "voter": 27743, + "use this library ": 27744, + "BIT_LENGTH": 27745, + ";\\r\\n ": 27746, + "), \\\"SafeERC20: ": 27747, + "Month": 27748, + "s are done ": 27749, + "updateCodeHash": 27750, + "last owner.\\n // - `startTimestamp` to the timestamp of ": 27751, + "++] = ": 27752, + "Check the ": 27753, + "downscal": 27754, + "multisig": 27755, + ".\\n interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata.": 27756, + ".\\n interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721": 27757, + "Packs ": 27758, + "tokensForMarketing ": 27759, + "Bytes ": 27760, + "Bytecode": 27761, + "To use this library ": 27762, + "Allows ": 27763, + "validator": 27764, + "ST_": 27765, + "`. For ": 27766, + "\\n // - ": 27767, + "Info(": 27768, + "Info[": 27769, + "BaseToken": 27770, + " = _currentIndex": 27771, + "transferred from `from` to `to": 27772, + "Partic": 27773, + "ERC20 operations that ": 27774, + "\\n\\n /**\\n * @dev Returns the ": 27775, + "_checkRole": 27776, + "also supported, ": 27777, + "3600": 27778, + "low-level call failed": 27779, + "|| msg.sender == ": 27780, + "2**64.": 27781, + "Lockup": 27782, + "if (!isApprovedOrOwner": 27783, + "if (!hasRole(role, account)) {\\n ": 27784, + "lpWithdrawRequest": 27785, + ", the last ": 27786, + "_currentIndex != end": 27787, + ".sol\\\";\\nimport \\\"./I": 27788, + "Arg": 27789, + ", but also ": 27790, + "next owner.\\n // - `startTimestamp` to the timestamp of ": 27791, + "Transfers `tokenId` from `from` to `to`": 27792, + "standard for ": 27793, + "address) {\\n return address(uint160(_packedOwnershipOf(tokenId": 27794, + "map, ": 27795, + "10**18": 27796, + "below": 27797, + "swapTokensForEth(uint256 tokenAmount": 27798, + ") {\\n return _": 27799, + "safe operations ": 27800, + "values on a ": 27801, + "offset, ": 27802, + "this contract does not ": 27803, + "auxillary data for `owner`. (e.g. number of whitelist mint slots used": 27804, + "tick of the ": 27805, + "consuming and ": 27806, + "array of `": 27807, + "_INVARIANT": 27808, + "process, the last ": 27809, + "add a `": 27810, + "Oracle ": 27811, + "around ERC20 operations that ": 27812, + "\\n ) external returns (uint[] memory amounts);\\n function ": 27813, + "\\n ) external returns (uint amountToken, uint amountETH": 27814, + "\\n ) external returns (uint amountETH": 27815, + ".\\n // This is equivalent to `packed -= 1; packed += 1": 27816, + ";\\n _decimals = 18": 27817, + "utils/Context.sol\\\";\\n\\n/**\\n * @dev Extension of {ERC20} that allows token holders to destroy both their own\\n * tokens and those that they have an allowance for, in a way that can be\\n * recognized off-chain (via event analysis).\\n */\\nabstract contract ERC20Burnable is Context, ERC20 {\\n /**\\n * @dev Destroys `amount` tokens from the caller.\\n *\\n * See {ERC20-_burn}.\\n */\\n function burn(uint256 amount) public virtual {\\n _burn(_msgSender(), amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, deducting from the caller's\\n * allowance.\\n *\\n * See {ERC20-_burn} and {ERC20-allowance}.\\n *\\n * Requirements:\\n *\\n * - the caller must have allowance for ``accounts``'s tokens of at least\\n * `amount`.\\n */\\n function burnFrom(address account, uint256 amount) public virtual ": 27818, + "userData.": 27819, + "BasisPoint": 27820, + "returns false). ": 27821, + ";\\n } ": 27822, + "\\n /// @return amount": 27823, + "as `token.safeTransfer(": 27824, + "Assets": 27825, + "ensureInputLength": 27826, + ";\\n\\n // Updates:\\n // - `address` to the ": 27827, + "separate ": 27828, + "AdminRole, adminRole": 27829, + "mload(add(table": 27830, + "\\n\\n // Updates:\\n // - `address` to the ": 27831, + "...)`, ": 27832, + "].add(amount": 27833, + "invol": 27834, + "Status.": 27835, + "market.total": 27836, + "handle ": 27837, + "unrealistic": 27838, + "`.\\n // - `numberBurned += 1": 27839, + "_baseURI() internal view virtual override returns (": 27840, + "you can add a `": 27841, + "| |\\n * ": 27842, + "_CACHED_THIS": 27843, + "on failure) are ": 27844, + "reserves": 27845, + "DefaultRoyalty(address ": 27846, + "\"// SPDX-License-Identifier: GPL-3.0-or-later\\npragma solidity 0.8.17": 27847, + "ConsecutiveTransfer} event": 27848, + ");\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role": 27849, + "service": 27850, + "for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool approved": 27851, + ", \\\"ERC721: approve to caller": 27852, + "from != owner() ": 27853, + "if (a >= ": 27854, + "spendAllowance(account": 27855, + "_init_unchained": 27856, + "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB": 27857, + "verification of ": 27858, + ".\\n unchecked {\\n // We can directly increment and decrement the balances": 27859, + "overridden by the ": 27860, + " {\\n function onERC721Received(\\n address operator,\\n address from,\\n uint256 tokenId,\\n bytes calldata data\\n ) external returns (bytes4);\\n}\\n\\n": 27861, + ",uint256 nonce,uint256 expiry": 27862, + "character is ": 27863, + "MUST NOT ": 27864, + "Limit = ": 27865, + "name = _": 27866, + "statement to your contract": 27867, + "KODA": 27868, + "to.code.length != 0) {\\n ": 27869, + "`.\\n //\\n // We can directly decrement the balance, and increment the number burned": 27870, + "hashPair(computedHash, ": 27871, + "` functions. ": 27872, + "token/ERC20/extensions/ERC20Burnable.sol\"": 27873, + ".\\n unchecked {\\n // Updates:\\n // - `balance -= 1": 27874, + "TransferHelper.safeTransfer": 27875, + "sent to the ": 27876, + "chain id to ": 27877, + "efficient minting ": 27878, + ".\\n //\\n // Bits Layout:\\n // - [0..": 27879, + "calendar": 27880, + "throw on failure ": 27881, + "throw on failure) are ": 27882, + "branchless ": 27883, + "(_packedOwnershipOf(tokenId)": 27884, + "value (and instead ": 27885, + "RARELOOKSR": 27886, + "(address, address": 27887, + "uint256) private _balances;\\n\\n mapping (address => mapping (address => uint256": 27888, + ", uint256 index) internal view returns (address) {\\n return ": 27889, + "_startTokenId();\\n }\\n }\\n\\n /**\\n * @dev Returns the total amount of tokens minted in the contract.\\n */\\n function _totalMinted(": 27890, + "_startTokenId();\\n }\\n }\\n\\n /**\\n * @dev Returns the total number of tokens burned.\\n */\\n function _totalBurned(": 27891, + "bytes32 digest = _hashTypedDataV4(": 27892, + "\"Insufficient Balance\"": 27893, + "call the safe operations ": 27894, + ");\\n }\\n return computedHash": 27895, + "Ptr, and(": 27896, + "() external pure returns (string memory);\\n function ": 27897, + "bankx": 27898, + "producing values on a ": 27899, + "(when the token": 27900, + "index = end - ": 27901, + "mixin": 27902, + "(uint16 _srcChainId, bytes calldata ": 27903, + "baseTokenForPair": 27904, + "outside of contract ": 27905, + "computedHash = _hashPair(computedHash, ": 27906, + "reduceFee": 27907, + "\\n ) external returns (uint amountA, uint amountB);\\n function ": 27908, + "(\\n bytes32[] calldata proof,\\n bool[] calldata ": 27909, + "may\\n * ": 27910, + "proof[i]);\\n }\\n return computedHash": 27911, + "_burnCounter - _startTokenId();\\n }\\n }\\n\\n /**\\n * @dev Returns the total amount of tokens minted in the contract.\\n */\\n function _totalMinted(": 27912, + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n uint256 c = a + b;\\n require(c >= a, \\\"SafeMath: addition overflow\\\");\\n return c": 27913, + "immediately ": 27914, + "Satoshis": 27915, + "OperatorFilterer {\\n /// @dev ": 27916, + "_checkContractOnERC721Received(from, to, tokenId, _data)) {\\n ": 27917, + "PUT_AMOUNT": 27918, + ", i.e. the ": 27919, + ", bytes32 leaf) internal pure returns (bytes32) {\\n bytes32 computedHash = leaf;\\n for (uint256 i = 0; i < proof.length; i++) {\\n computedHash = _hashPair(computedHash, ": 27920, + "owner != operator": 27921, + ",\\n address to,\\n uint256 ": 27922, + "return\\n interfaceId == 0x01ffc9a7 || // ERC165 interface ID for ERC165": 27923, + "cause an overflow": 27924, + "ownership = _ownershipAt": 27925, + ").interfaceId || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account": 27926, + "addLiquidityETH(\\n address token,\\n uint amountTokenDesired,\\n uint amountTokenMin,\\n uint amountETHMin,\\n address to,\\n uint deadline": 27927, + "RoleAdminChanged(role, previous": 27928, + "onto ": 27929, + "ROLE_ERC20": 27930, + "IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Enumerable is IERC721 {\\n /**\\n * @dev Returns the ": 27931, + "which allows you to ": 27932, + " bits\\r\\n *\\r\\n * _Available since v4.": 27933, + "non-reverting calls are assumed to ": 27934, + "abi.decode(returndata, (bool)": 27935, + ", timestamp()), ": 27936, + "Tokens that return no ": 27937, + "prizes": 27938, + "_balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount": 27939, + ", address indexed from, address indexed to": 27940, + ") external;\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n}\\n\"": 27941, + "queue starts with the ": 27942, + "MULTIP": 27943, + "prettier-ignore\\n if iszero(": 27944, + "s\\\":[{\\\"internalType\\\":\\\"": 27945, + "Emits a {Transfer} event with ": 27946, + "revert(\\n string(\\n abi.encodePacked(\\n \\\"AccessControl: account ": 27947, + "Emergency": 27948, + "BITPOS_NUMBER_BURNED) - 1;\\n\\n // Updates:\\n // - `address` to the ": 27949, + "sometimes called as 'swap and pop": 27950, + "BITMASK_BURNED = 1 << 224;\\n\\n // The bit position": 27951, + "Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControl": 27952, + "length,\\n // and 3 ": 27953, + "_approve(account, _msgSender(), ": 27954, + "implementing it ourselves. We ": 27955, + ");\\n if (to.code.length != 0)\\n if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {\\n ": 27956, + "starting token ID.\\n * To change the starting token ID, please override this function.\\n */\\n function _startTokenId() internal view virtual returns (uint256) {\\n return 0;\\n }\\n\\n /**\\n * @dev Returns the next token ID to be minted.\\n */\\n function _nextTokenId": 27957, + "uint256) {\\n // Counter underflow is impossible as _burnCounter cannot be incremented\\n // more than `_currentIndex - _startTokenId()` times.\\n unchecked {\\n ": 27958, + "Returns an Ethereum Signed Message, created from `s`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n\\\", Strings.toString(s.length), s": 27959, + "over ``owner``'s tokens,\\n * given ``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\"": 27960, + "\"convex-platform": 27961, + ";` statement to your contract": 27962, + "a,\\r\\n uint256 b": 27963, + "from` cannot be the zero address.\\n * - `to` cannot be the zero address": 27964, + "burning.\\n // - `burned` to `true`.\\n // - `nextInitialized` to `": 27965, + "\\n * @dev Wrappers around ERC20 operations that ": 27966, + "last owner.\\n // - `startTimestamp` to the timestamp of burning.\\n // - `burned` to `true`.\\n // - `nextInitialized` to `": 27967, + ".\\n interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721.\\n interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata.": 27968, + "To use this library you can add a `": 27969, + "also supported, non-reverting calls are assumed to ": 27970, + "if (!hasRole(role, account)) {\\n revert(\\n string(\\n abi.encodePacked(\\n \\\"AccessControl: account ": 27971, + "next owner.\\n // - `startTimestamp` to the timestamp of transfering.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `": 27972, + "consuming and producing values on a ": 27973, + "\\n ) external returns (uint amountToken, uint amountETH);\\n function ": 27974, + "returns false). Tokens that return no ": 27975, + "as `token.safeTransfer(...)`, ": 27976, + "ensureInputLengthMatch": 27977, + "mload(add(tablePtr, and(": 27978, + "\\n\\n // Updates:\\n // - `address` to the next owner.\\n // - `startTimestamp` to the timestamp of transfering.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `": 27979, + "`.\\n // - `numberBurned += 1`.\\n //\\n // We can directly decrement the balance, and increment the number burned": 27980, + ".\\n unchecked {\\n // We can directly increment and decrement the balances.\\n ": 27981, + ".\\n unchecked {\\n // Updates:\\n // - `balance -= 1`.\\n // - `numberBurned += 1`.\\n //\\n // We can directly decrement the balance, and increment the number burned": 27982, + "throw on failure (when the token": 27983, + "throw on failure) are also supported, non-reverting calls are assumed to ": 27984, + "value (and instead revert ": 27985, + "call the safe operations as `token.safeTransfer(...)`, ": 27986, + "index = end - quantity": 27987, + "(\\n bytes32[] calldata proof,\\n bool[] calldata proofFlags": 27988, + ", bytes32 leaf) internal pure returns (bytes32) {\\n bytes32 computedHash = leaf;\\n for (uint256 i = 0; i < proof.length; i++) {\\n computedHash = _hashPair(computedHash, proof[i]);\\n }\\n return computedHash": 27989, + "return\\n interfaceId == 0x01ffc9a7 || // ERC165 interface ID for ERC165.\\n interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721.\\n interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata.": 27990, + "RoleAdminChanged(role, previousAdminRole, adminRole": 27991, + "which allows you to call the safe operations as `token.safeTransfer(...)`, ": 27992, + "BITPOS_NUMBER_BURNED) - 1;\\n\\n // Updates:\\n // - `address` to the last owner.\\n // - `startTimestamp` to the timestamp of burning.\\n // - `burned` to `true`.\\n // - `nextInitialized` to `": 27993, + "sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex": 27994, + "\"convex-platform/contracts/contracts/": 27995, + "\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token": 27996, + "consuming and producing values on a queue": 27997, + "returns false). Tokens that return no value (and instead revert ": 27998, + ".\\n unchecked {\\n // Updates:\\n // - `balance -= 1`.\\n // - `numberBurned += 1`.\\n //\\n // We can directly decrement the balance, and increment the number burned.\\n // This is equivalent to `packed -= 1; packed += 1": 27999, + "which allows you to call the safe operations as `token.safeTransfer(...)`, etc": 28000, + "\"0": 28001, + "));\\n return ": 28002, + "0];\\n } else {\\n return ": 28003, + "2000": 28004, + "924": 28005, + ":\\n // - ": 28006, + "DEX": 28007, + "Frequency ": 28008, + "IGet": 28009, + "Sw": 28010, + "SUPP": 28011, + "Vote": 28012, + "X\"": 28013, + "[xxx": 28014, + "_project": 28015, + "_state": 28016, + "_accounts": 28017, + "_hashPair": 28018, + "_MANAG": 28019, + "`quantity": 28020, + "`aux": 28021, + "`nextInitialized` ": 28022, + "`(quantity == 1": 28023, + "c0": 28024, + "fter": 28025, + "gold": 28026, + "ko": 28027, + "match ": 28028, + "sToken": 28029, + " ADDRESS": 28030, + "\\n{\\n ": 28031, + "\\n@@@@@@@@@@@@@@@@@@@@@@@@": 28032, + "\\n );\\n ": 28033, + "revoc": 28034, + "s values are ": 28035, + "inf": 28036, + ", balance": 28037, + ", EIP712": 28038, + ", uint16 ": 28039, + ", uint24 extraData": 28040, + "unwrap": 28041, + "256bit ": 28042, + "uint256)\\\"))": 28043, + "\\n * an ": 28044, + "\\n * pair of ": 28045, + "trailing ": 28046, + "atew": 28047, + "token.\\n * ": 28048, + "ityt": 28049, + "cosum": 28050, + "ses are done ": 28051, + "\\\".\\n ": 28052, + "\\\"pop": 28053, + "\\\". If ": 28054, + "\\\"pointers": 28055, + "` - the ": 28056, + "` field": 28057, + "` have a ": 28058, + "uint256 value": 28059, + "\\n * - ": 28060, + "note": 28061, + "value_": 28062, + " = amount": 28063, + " = leaves": 28064, + ".\\n */\\n function verify": 28065, + ",\\n function": 28066, + ");\\n _owner = newOwner": 28067, + ") {\\n ownership.addr = address(uint160(packed));\\n ownership.startTimestamp = uint64(": 28068, + "(address minter": 28069, + "and value for the ": 28070, + "} as defined ": 28071, + "\\n ? ": 28072, + "\\n );\\n ": 28073, + "total of ": 28074, + "totalMinted": 28075, + ";\\n bytes32 ": 28076, + "), eq(msgSender, ": 28077, + "Contain": 28078, + "from rightmost dig": 28079, + "by travers": 28080, + "adding ": 28081, + "msgSender := and(": 28082, + "if (currOwnershipAddr == owner": 28083, + "balance1": 28084, + "behave ": 28085, + "string constant ": 28086, + "maxTokenSupplyForStage": 28087, + "namic": 28088, + "Called ": 28089, + "the\\n // ": 28090, + "This account ": 28091, + "currentInvariant": 28092, + ";\\n\\nlibrary ": 28093, + ";\\n\\nimport \\u0027./": 28094, + ");\\n\\n error ": 28095, + "with verification of ": 28096, + ");\\n\\n return (": 28097, + ";\\n\\n /// ": 28098, + "Mints `quantity` tokens and transfers them to `to`.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `quantity` must be greater than 0": 28099, + "'s \\\"pop": 28100, + ", \\\"S": 28101, + "illcreate": 28102, + " * n": 28103, + "person": 28104, + " The ": 28105, + "ting ERC721 ": 28106, + "bytes32 a = ": 28107, + "bytes32 b = ": 28108, + "INEL": 28109, + "balanceOf(from": 28110, + "mods": 28111, + "// Store": 28112, + "`fromTokenId": 28113, + "SwapTokens": 28114, + "composition": 28115, + " of the chain": 28116, + "\"// SPDX-License-Identifier: Apache-2.0": 28117, + ";\\n bytes32 private immutable _": 28118, + ".\\n */\\n function _require": 28119, + "hashPo": 28120, + "hashes on the ": 28121, + "hash.\\n // - ": 28122, + "hashes = new ": 28123, + "` cannot be set on ": 28124, + "(_srcChainId": 28125, + "+ proof": 28126, + "s, leaves": 28127, + "` to `toTokenId": 28128, + "amount -= ": 28129, + "set if `": 28130, + "If not burned": 28131, + " != 0;\\n ": 28132, + "only one {": 28133, + ":= extraData": 28134, + "in the `hashes": 28135, + "StringSlot": 28136, + "].\\n * ": 28137, + "field ": 28138, + "Enables ": 28139, + " == totalHashes": 28140, + "`tokenId` has a ": 28141, + "using two values": 28142, + "PoolPoints": 28143, + "24bit ": 28144, + "24 bits for `": 28145, + "_mint(to, amount": 28146, + "\\\");\\n\\n // The ": 28147, + "quantity, 1": 28148, + "operating": 28149, + "::permit": 28150, + "grantRole(": 28151, + "non-compliant with the ": 28152, + "storage tokenApproval": 28153, + ";\\r\\n\\r\\n ": 28154, + "3.68": 28155, + ") public view virtual override returns (uint256) {\\r\\n return ": 28156, + "ENTINEL": 28157, + "roundUp": 28158, + "should contain the ": 28159, + "proof` must be ": 28160, + "proofs can be ": 28161, + "proofs.\\n *\\n * The ": 28162, + "proof[0];\\n ": 28163, + "proof[proof": 28164, + "(from, to, extraData": 28165, + "(address account, address ": 28166, + "es[i": 28167, + "signature\\n * @param ": 28168, + "Pos values are ": 28169, + "ing the tree up": 28170, + "using\\n // `": 28171, + "token/ERC20/SafeERC20": 28172, + "`owner | (": 28173, + "tic due to the ": 28174, + "gas optimization": 28175, + "special ": 28176, + "DREAM": 28177, + "For branchless ": 28178, + ");\\n _packedAddressData[owner": 28179, + "temp) { break ": 28180, + "\\\");\\n require(_": 28181, + "solad": 28182, + "packed == 0) {\\n ": 28183, + "Router02": 28184, + "0.8.9": 28185, + "0.8.13": 28186, + ".sol\\\";\\n\\n/**\\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\\n *\\n * These functions can be used to verify that a message was signed by the holder\\n * of the private keys of a given address.\\n */\\nlibrary ECDSA {\\n enum RecoverError {\\n NoError,\\n InvalidSignature,\\n InvalidSignatureLength,\\n InvalidSignatureS,\\n InvalidSignatureV": 28187, + " from the\\n // ": 28188, + "ing\\n * sibling ": 28189, + "Change ": 28190, + "into position": 28191, + "- `spender` cannot be the zero address": 28192, + "Balance exceeds ": 28193, + ";\\n emit RoleAdminChanged(role, previousAdminRole, adminRole": 28194, + "array. All ": 28195, + "assets, ": 28196, + "assets` ": 28197, + "T_ROLE": 28198, + "with the ERC2309": 28199, + "Rounds": 28200, + "ault to ": 28201, + "Emitted when tokens in ": 28202, + "Weight = ": 28203, + "to the root of the tree. ": 28204, + "the caller is ": 28205, + "each token transfer to ": 28206, + "each array. All ": 28207, + "have been consum": 28208, + "Liquidate": 28209, + " overflows on the ": 28210, + "we\\n // ": 28211, + "containing\\n * sibling ": 28212, + "Strings.sol\\\";\\n\\n/**\\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\\n *\\n * These functions can be used to verify that a message was signed by the holder\\n * of the private keys of a given address.\\n */\\nlibrary ECDSA {\\n enum RecoverError {\\n NoError,\\n InvalidSignature,\\n InvalidSignatureLength,\\n InvalidSignatureS,\\n InvalidSignatureV": 28213, + "ERC721 standard": 28214, + "ERC721 compli": 28215, + "equivalent to `approved": 28216, + ")\\n let ": 28217, + "expected to be ": 28218, + "for (uint256 i; i": 28219, + "ance, sub": 28220, + "setting of the `nextInitialized` ": 28221, + " or the ": 28222, + "next value to ": 28223, + "price that ": 28224, + ") {\\n // This function ": 28225, + "extraData` before ": 28226, + "extraData(from, to, extraData": 28227, + "reasurydao": 28228, + "encoded": 28229, + "} event.\\n */\\n function _mint": 28230, + ".\\n\\n // ": 28231, + "s.length;\\n\\n // Check ": 28232, + "permissible ": 28233, + "make your contract": 28234, + "shared": 28235, + ");\\r\\n\\r\\n uint256 ": 28236, + "swapExactTokensForETHSupportingFeeOnTransferTokens(\\n uint amountIn,\\n uint amountOutMin,\\n address[] calldata path,\\n address to,\\n uint deadline\\n ": 28237, + "(address(0), to, index": 28238, + ". The root is ": 28239, + ". The queue starts with the ": 28240, + "Params(": 28241, + "flag, either ": 28242, + "result is shifted ": 28243, + "calculated": 28244, + "uint160(account": 28245, + "\\tif ": 28246, + "salePrice * ": 28247, + "consume in ": 28248, + "src/\"": 28249, + "TION ": 28250, + ") external returns (uint256 ": 28251, + ");\\n uint256 leafPo": 28252, + "hash by travers": 28253, + "hash in the `hashes": 28254, + "hash using two values": 28255, + "registerTokens": 28256, + "Removes ": 28257, + "leaves. The root is ": 28258, + "StartTime ": 28259, + "returned result is shifted ": 28260, + "ProxyOwner": 28261, + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../ERC20.sol\\\";\\nimport \\\"../../../": 28262, + "ERC2309 exceeds the ": 28263, + "ownership.extraData = uint24(": 28264, + "license ": 28265, + "// The following is ": 28266, + "a `leaf` ": 28267, + "a `proof` must be ": 28268, + "} else if (leavesLen ": 28269, + ", we compute the next ": 28270, + "_startTokenId() ": 28271, + "`index`.\\n */\\n function _": 28272, + "root`. For ": 28273, + "For a limit of ": 28274, + "_isExcludedMaxTransactionAmount[to]": 28275, + "\\n */\\n error ": 28276, + "root of\\n // the ": 28277, + "root hash by travers": 28278, + "queried": 28279, + "called.\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals": 28280, + "BITMASK_ADDRESS = (1 << ": 28281, + "leaves and each ": 28282, + "leaves have been consum": 28283, + "[_of": 28284, + " = 232": 28285, + " = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc": 28286, + "cannot overflow.\\r\\n */\\r\\n function ": 28287, + "`, which return the current value and ": 28288, + ";\\n\\n /**\\n * @dev ": 28289, + "(\\r\\n address indexed ": 28290, + "; i++) {\\n bytes32 a = ": 28291, + "set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address": 28292, + "quantity` equals 1": 28293, + "quantity` that can be minted ": 28294, + "Max Transaction ": 28295, + "ln_36": 28296, + "at(index": 28297, + "token ids are ": 28298, + ", which is unrealistic": 28299, + "uniswapRouter": 28300, + "full ERC721 compli": 28301, + "bytes32[] memory hashes = new ": 28302, + " is only permissible ": 28303, + "Randomizer": 28304, + "\\n ) internal pure returns (bytes32 merkleRoot": 28305, + "totalHashes = ": 28306, + "VRFCoordinator": 28307, + "unrealistic due to the ": 28308, + "maximum `quantity` that can be minted ": 28309, + "proofFlags, leaves": 28310, + "proofFlags.length;\\n\\n // Check ": 28311, + "`\\n // - [160..223] `startTimestamp": 28312, + "`\\n // - [64..127] `numberMinted": 28313, + "`\\n // - [128..191] `numberBurned": 28314, + "`\\n // - [224] `burned": 28315, + "`\\n // - [192..255] `aux": 28316, + "`\\n // - [225] `nextInitialized": 28317, + "\\n * a default value of 18": 28318, + "in a packed ownership ": 28319, + "\\n virtual\\n override\\n ": 28320, + "governor": 28321, + "utils/Strings.sol\\\";\\nimport \\\"../": 28322, + "votes : 0": 28323, + "ceiling": 28324, + "the\\n // `hashes": 28325, + "domainseparator": 28326, + "above check for ": 28327, + "thus mim": 28328, + "232..255] `": 28329, + "resetting ": 28330, + "BITPOS_EXTRA_DATA = 232": 28331, + "packOwnershipData(address owner, uint256 ": 28332, + "value == 0) || (": 28333, + "ed for efficient minting ": 28334, + "Spender": 28335, + "{\\n /**\\n * @dev Returns true if a `leaf` ": 28336, + "uint24 extraData = uint24(": 28337, + "a value from the \\\"main queue": 28338, + "ConsecutiveTransfer(uint256 indexed ": 28339, + "ConsecutiveTransfer} as defined ": 28340, + "IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc": 28341, + "uint256(_extraData(from, to, extraData": 28342, + "5000, a ": 28343, + ".\\n ///\\n /// ": 28344, + "lower 160 bits for ": 28345, + "queue's \\\"pop": 28346, + "s) with the ERC2309": 28347, + "BITPOS_START_TIMESTAMP) | ": 28348, + "BITPOS_START_TIMESTAMP, timestamp()), ": 28349, + "Active = ": 28350, + ".\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply = _totalSupply.add(amount);\\n _balances[account] = _balances[account].add(amount);\\n emit Transfer": 28351, + "` array, then ": 28352, + "` array.\\n for (uint256 i = 0; i < ": 28353, + "` array. At the ": 28354, + "from != to": 28355, + "set the 24bit ": 28356, + "communityt": 28357, + "BITMASK_NEXT_INITIALIZED |": 28358, + "try ERC721A__IERC721Receiver(to).onERC721Received": 28359, + "(a, b);\\n }\\n\\n if (": 28360, + " = (1 << 232": 28361, + "totalHashes);\\n uint256 leafPo": 28362, + "totalHashes; i++) {\\n bytes32 a = ": 28363, + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n enum Rounding {\\n Down, // Toward negative infinity\\n Up, // Toward infinity\\n Zero // Toward zero\\n }\\n\\n /**\\n * @dev Returns the largest of two numbers.\\n */\\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a > b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2;\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute.\\n return a == 0 ? 0 : (a - 1) / b + 1;\\n }\\n\\n /**\\n * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\\n * with further edits by Uniswap Labs also under MIT license": 28364, + "5` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals": 28365, + "callable by ": 28366, + "\\\" (merging ": 28367, + "hashes[totalHashes ": 28368, + "hashes[i] = _": 28369, + " from the leaves. The root is ": 28370, + "otherwise we\\n // ": 28371, + "leavesLen + proof": 28372, + "Sync(": 28373, + "accesses are done ": 28374, + "toggleSwap": 28375, + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)": 28376, + "_packedOwnerships;\\n\\n // Mapping owner address to address data": 28377, + "BITPOS_AUX);\\n _packedAddressData[owner": 28378, + "        ": 28379, + "\\n //\\n // Bits Layout:\\n // - [0..": 28380, + "`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token\\n * by either {approve} or {setApprovalForAll}.\\n * - ": 28381, + "BITPOS_NEXT_INITIALIZED, eq(": 28382, + "3009": 28383, + "leaf to the root of the tree. ": 28384, + "proof validity": 28385, + "nextInitializedFlag(uint256 quantity": 28386, + "Merkle T": 28387, + "BITMASK_BURNED |": 28388, + ".\\n uint256 private _burnCounter;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to ownership details\\n // An empty struct value does not necessarily mean the token is unowned": 28389, + ".\\n uint256 private _currentIndex;\\n\\n // The number of tokens burned": 28390, + "\"// SPDX-License-Identifier: GPL-3.0-or-later\\n// This program is free software: you can redistribute it and/or modify\\n// it under the terms of the GNU General Public License as published by\\n// the Free Software Foundation, either version 3 of the License, or\\n// (at your option) any later version.\\n\\n// This program is distributed in the hope that it will be useful,\\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\n// GNU General Public License for more details.\\n\\n// You should have received a copy of the GNU General Public License\\n// along with this program. If not, see .\\n\\npragma solidity ^0.7.0;\\npragma experimental ABIEncoderV2": 28391, + ".\\r\\n */\\r\\n event ": 28392, + "branch from the ": 28393, + "approvedAddress := sload(": 28394, + "end of the process, the last ": 28395, + "At(uint256 index, uint24 extraData": 28396, + ";\\n\\n // Mapping from token ID to approved address.\\n mapping(uint256 => ": 28397, + ".\\n uint256 leavesLen": 28398, + "xxx[xxx": 28399, + "xxxPos values are ": 28400, + "facilitate ": 28401, + "startTokenId + quantity - 1": 28402, + "distributionContract": 28403, + ");\\n uint256 c = a / b": 28404, + "hashPair(a, b);\\n }\\n\\n if (": 28405, + ") {\\n assembly {\\n // The maximum value of a uint256 contains 78 digits (1 byte per digit": 28406, + "`balance` and `numberMinted` have a ": 28407, + "leaves[0];\\n } else {\\n return ": 28408, + "`extraData` field": 28409, + "Half ": 28410, + "Mask `msgSender": 28411, + "() external view override returns (bytes32) {\\n return _": 28412, + "contains contract ": 28413, + "each step, we compute the next ": 28414, + "pair of pre-images are assumed to be sorted": 28415, + "(proof, proofFlags, leaves": 28416, + ");\\n }\\n\\n /**\\n * @dev Approve `operator` to operate on all of `owner` tokens": 28417, + "mapping(bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev ": 28418, + ");\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token\\n * by either {approve} or {setApprovalForAll}.\\n * - ": 28419, + "communitymods": 28420, + "Address.isContract(": 28421, + "These functions deal ": 28422, + ") external returns(bool)": 28423, + "Address = _tokenApproval": 28424, + "STORAGE\\n //////////////////////////////////////////////////////////////*/\\n\\n ": 28425, + "simultane": 28426, + "Role = getRoleAdmin(role": 28427, + ".\\n */\\n function _safeMint(\\n address to,\\n uint256 quantity": 28428, + "an element from the\\n // ": 28429, + "override returns (bool) {\\n // The interface IDs are constants representing the first 4": 28430, + "_EXTRA_DATA_COMPLEMENT = (1 << 232": 28431, + "MAX_MINT_ERC2309_QUANTITY_LIMIT = 5000": 28432, + "previousExtraData` - the ": 28433, + "9e15 ": 28434, + "except the 24 bits for `": 28435, + "`proof` array.\\n for (uint256 i = 0; i < ": 28436, + "(_msgSenderERC721A(), from, tokenId, _data) returns (": 28437, + "into a single uint256": 28438, + "address data entries.": 28439, + "increment the pointer, ": 28440, + "auxiliary data for `owner`. (e.g. number of whitelist mint slots used).\\n * If there are multiple variables, please pack them into a uint64.\\n */\\n function _setAux(address owner, uint64 aux": 28441, + "auxiliary data for `owner`. (e.g. number of whitelist mint slots used).\\n */\\n function _getAux(address owner) internal view returns (uint64) {\\n return ": 28442, + "> 0) {\\n return leaves[0];\\n } else {\\n return ": 28443, + "s = 0;\\n uint256 proofPo": 28444, + "s = 0;\\n uint256 hashPo": 28445, + "ownership data into a single uint256": 28446, + "extraDataCasted := extraData": 28447, + "maximum limit of 2**256": 28448, + "maximum limit of 2**64.": 28449, + ".\\n *\\n * Emits a {Transfer} event for each mint.\\n */\\n function _mint": 28450, + ".\\n *\\n * Emits a {Transfer} event for each mint.\\n */\\n function _safeMint(\\n address to,\\n uint256 quantity": 28451, + "get the next leaf, ": 28452, + "get the next hash.\\n // - ": 28453, + "Pos++];\\n bytes32 b = ": 28454, + "Pos++];\\n hashes[i] = _": 28455, + "extra data for the packed ownership ": 28456, + "extra data for the ownership data ": 28457, + "{Transfer} event(s) with the ERC2309": 28458, + "leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];\\n bytes32 b = ": 28459, + "https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator": 28460, + "rebuilt by\\n // ": 28461, + "Equivalent to `safeTransferFrom(from, to, tokenId, '')`.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ": 28462, + "caller is not token owner or ": 28463, + "inclusive) is ": 28464, + "EXPIRED": 28465, + "this, a `proof` must be ": 28466, + "signedMintValidation": 28467, + "sets the extra data for the ownership data ": 28468, + "depending on the flag, either ": 28469, + "manifold.xyz": 28470, + "safety limit": 28471, + "Description": 28472, + "ecosystem ": 28473, + "implementation for details.\\n //\\n // Bits Layout:\\n // - [0..": 28474, + "`\\n mapping(address => uint256) private _packedAddressData": 28475, + "startTimestamp` that can be set ": 28476, + "intended for efficient minting ": 28477, + "primitive": 28478, + "s = 0;\\n // At ": 28479, + ")\\n private\\n view\\n returns (uint256 ": 28480, + "if (!_checkContractOnERC721Received(address(0), to, index": 28481, + "data similar to `": 28482, + "(from, address(0), prevOwnershipPacked": 28483, + "flag set if `": 28484, + "`leaves` array, then ": 28485, + ") or an element from the\\n // ": 28486, + "TYPE_HASH, _": 28487, + "` array should contain the ": 28488, + "provided, containing\\n * sibling ": 28489, + "limit is to prevent": 28490, + "} is\\n * called.\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals": 28491, + "Accumulator": 28492, + ".\\n require(leavesLen + proof": 28493, + "creation WILL ": 28494, + "IERC721A {\\n /**\\n * The caller must own the token or be an approved operator.\\n */\\n error ApprovalCallerNotOwnerNorApproved();\\n\\n /**\\n * The token does not exist.\\n */\\n error ApprovalQueryForNonexistentToken": 28495, + "equivalent": 28496, + "tree\\n * defined by `": 28497, + "JavaScript library": 28498, + "goes onto ": 28499, + ", prevOwnershipPacked": 28500, + "storage slot and value for the ": 28501, + "members;\\n bytes32 adminRole;\\n }\\n\\n mapping(bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev ": 28502, + "threshold": 28503, + "` to be below the ": 28504, + "tokenId < _currentIndex && // If within bound": 28505, + "} 1 {} {\\n ": 28506, + "using SafeERC20 for IERC20;` statement to your contract": 28507, + ".sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 ": 28508, + "] <= 2500": 28509, + "merkle tree.\\n uint256 leavesLen": 28510, + "stituting ERC721 ": 28511, + "StartingIndex": 28512, + "Each\\n * pair of ": 28513, + "(address from, address to, uint256 amount) internal virtual { }\\n}\\n\"": 28514, + "mapping(address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping(bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev ": 28515, + "PERMIT_TYPEHASH, owner, spender, value": 28516, + "(success, ) = ": 28517, + ".\\n *\\n * To select a different value for {decimals}, use {_setupDecimals": 28518, + ".length;\\n uint256 totalHashes = ": 28519, + "string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals": 28520, + "value of `extraData` before ": 28521, + "Arbitrary data similar to `": 28522, + "MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` ": 28523, + "can be proved to be a part of a Merkle tree\\n * defined by `": 28524, + "andearn": 28525, + "(from, to, prevOwnershipPacked": 28526, + "uint256[] memory tokenIds = new uint256": 28527, + "(sender, recipient, amount);\\n\\n _balances[sender] = _balances[sender].sub(amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[recipient] = _balances[recipient].add(amount);\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` ": 28528, + "fromTokenId, uint256 toTokenId, address indexed from, address indexed to": 28529, + "is required to cause an overflow": 28530, + "msgSender == approvedAddress": 28531, + "Intended to be overridden by the ": 28532, + "hardhat": 28533, + "address(token).functionCall": 28534, + "sequence of {Transfer} event(": 28535, + "bytes memory returndata = address(token).functionCall": 28536, + "It emits only one {": 28537, + "instead of a sequence of {Transfer} event(": 28538, + "ed, we get the next leaf, ": 28539, + "mask of the lower 160 bits for ": 28540, + "icking a queue's \\\"pop": 28541, + "Pos++]`, which return the current value and ": 28542, + "159] `addr`\\n // - [160..223] `startTimestamp": 28543, + "}, initializes {decimals} with\\n * a default value of 18": 28544, + "We can directly compare the packed value.": 28545, + "63] `balance`\\n // - [64..127] `numberMinted": 28546, + "ed during each token transfer to ": 28547, + "Directly sets the extra data for the ownership data ": 28548, + ") internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721.ownerOf(tokenId);\\n return (spender == owner || ": 28549, + "toHexString(uint256(role), 32)\\n )\\n )\\n );\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role": 28550, + "t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\\n * instead returning `false` on failure. This behavior is nonetheless\\n * conventional and does not conflict with the expectations of ERC20\\n * applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping(address => uint256) private _balances;\\n\\n mapping(address => mapping(address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The default value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5.05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address to, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _transfer(owner, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``from``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 amount\\n ) public virtual override returns (bool) {\\n address spender = _msgSender();\\n _spendAllowance(from, spender, amount);\\n _transfer(from, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, allowance(owner, spender) + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n uint256 currentAllowance = allowance(owner, spender);\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - subtractedValue);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves `amount` of tokens from `from` to `to`.\\n *\\n * This internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {\\n require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(to != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, amount);\\n\\n uint256 fromBalance = _balances[from];\\n require(fromBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n unchecked {\\n _balances[from] = fromBalance - amount;\\n // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\\n // decrementing then incrementing.\\n _balances[to] += amount;\\n }\\n\\n emit Transfer(from, to, amount);\\n\\n _afterTokenTransfer(from, to, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n unchecked {\\n // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\\n _balances[account] += amount;\\n }\\n emit Transfer(address(0), account, amount);\\n\\n _afterTokenTransfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n unchecked {\\n _balances[account] = accountBalance - amount;\\n // Overflow not possible: amount <= accountBalance <= totalSupply.\\n _totalSupply -= amount;\\n }\\n\\n emit Transfer(account, address(0), amount);\\n\\n _afterTokenTransfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(\\n address owner,\\n address spender,\\n uint256 amount\\n ) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Updates `owner` s allowance for `spender` based on spent `amount`.\\n *\\n * Does not update the allowance amount in case of infinite allowance.\\n * Revert if not enough allowance is available.\\n *\\n * Might emit an {Approval} event.\\n */\\n function _spendAllowance(\\n address owner,\\n address spender,\\n uint256 amount\\n ) internal virtual {\\n uint256 currentAllowance = allowance(owner, spender);\\n if (currentAllowance != type(uint256).max) {\\n require(currentAllowance >= amount, \\\"ERC20: insufficient allowance\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - amount);\\n }\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {}\\n\\n /**\\n * @dev Hook that is called after any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * has been transferred to `to`.\\n * - when `from` is zero, `amount` tokens have been minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {}\\n}\\n\"": 28551, + "return data size checking mechanism, since\\n // ": 28552, + "Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * ": 28553, + "not all leaves have been consum": 28554, + "bytes32[](totalHashes);\\n uint256 leafPo": 28555, + ", \\\"MerkleProof: invalid multiproof\\\");\\n\\n // The ": 28556, + "(_packedOwnerships[index]);\\n }\\n\\n /**\\n * @dev ": 28557, + ";\\n }\\n _balances[to] += amount;\\n\\n emit Transfer": 28558, + "minted with ERC2309 exceeds the ": 28559, + "/// @author: manifold.xyz": 28560, + "Calling this function outside of contract ": 28561, + ".\\n */\\ninterface ERC721A__IERC721Receiver {\\n function onERC721Received(\\n address operator,\\n address from,\\n uint256 tokenId,\\n bytes calldata data\\n ) external returns (bytes4);\\n}\\n\\n": 28562, + "packed = _packedAddressData[owner];\\n uint256 aux": 28563, + "branches) or an element from the\\n // ": 28564, + "_packedOwnerships[index] == 0) {\\n _packedOwnerships[index] = _packedOwnershipOf(index);\\n }\\n }\\n\\n ": 28565, + "(uint256 packed) private pure returns (TokenOwnership memory ownership) {\\n ownership.addr = address(uint160(packed));\\n ownership.startTimestamp = uint64(": 28566, + "from `packed`.\\n */\\n function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership) {\\n ownership.addr = address(uint160(packed));\\n ownership.startTimestamp = uint64(": 28567, + " == 0; // and not burned.\\n }\\n\\n /**\\n * @dev ": 28568, + "BITPOS_AUX);\\n }\\n\\n /**\\n * Sets the auxiliary data for `owner`. (e.g. number of whitelist mint slots used).\\n * If there are multiple variables, please pack them into a uint64.\\n */\\n function _setAux(address owner, uint64 aux": 28569, + "call data (encoded using abi.encode or one of its variants": 28570, + "`\\n mapping(uint256 => uint256) private _packedOwnerships;\\n\\n // Mapping owner address to address data": 28571, + "\\\" to the next value to ": 28572, + "bytes32 previousAdminRole = getRoleAdmin(role": 28573, + "), \\\"SafeERC20: ERC20 operation did not succeed": 28574, + "Packs ownership data into a single uint256": 28575, + "if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved": 28576, + ";\\n _decimals = 18;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name": 28577, + "ConsecutiveTransfer} event is only permissible ": 28578, + "spendAllowance(account, _msgSender(), ": 28579, + ".\\n //\\n // Bits Layout:\\n // - [0..63] `balance`\\n // - [64..127] `numberMinted": 28580, + "abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed": 28581, + "prizesand": 28582, + "To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract": 28583, + "consuming and producing values on a queue. The queue starts with the ": 28584, + ":\\n // - a value from the \\\"main queue": 28585, + "`quantity` to be below the ": 28586, + "`nextInitialized` flag set if `": 28587, + "cosumer contract": 28588, + "\\\".\\n bytes32[] memory hashes = new ": 28589, + "\\\". If not all leaves have been consum": 28590, + "\\\"pointers\\\" to the next value to ": 28591, + "total of 3.68": 28592, + "), eq(msgSender, approvedAddress": 28593, + "from rightmost digit to ": 28594, + "msgSender := and(msgSender": 28595, + "with verification of Merkle T": 28596, + "Mints `quantity` tokens and transfers them to `to`.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `quantity` must be greater than 0.\\n *\\n * Emits a {Transfer} event for each mint.\\n */\\n function _mint": 28597, + "illcreateandearn": 28598, + "`fromTokenId` to `toTokenId": 28599, + "hashes on the branch from the ": 28600, + "` cannot be set on an unintialized ownership slot": 28601, + " == totalHashes, \\\"MerkleProof: invalid multiproof\\\");\\n\\n // The ": 28602, + "`tokenId` has a maximum limit of 2**256": 28603, + "operatingcosts": 28604, + "non-compliant with the ERC721 standard": 28605, + "proofs can be generated ": 28606, + "proof[proofPos++];\\n hashes[i] = _": 28607, + "ing the tree up from the leaves. The root is ": 28608, + "using\\n // `xxx[xxx": 28609, + "`owner | (block.timestamp": 28610, + "For branchless setting of the `nextInitialized` ": 28611, + "Balance exceeds wallet size": 28612, + "Emitted when tokens in `fromTokenId` to `toTokenId": 28613, + "each array. All accesses are done ": 28614, + " overflows on the address data entries.": 28615, + "equivalent to `approvedAddress = _tokenApproval": 28616, + "ance, substituting ERC721 ": 28617, + ") {\\n // This function rebuil": 28618, + "consume in each array. All accesses are done ": 28619, + "hash in the `hashes` array should contain the ": 28620, + "hash using two values:\\n // - a value from the \\\"main queue": 28621, + "returned result is shifted into position": 28622, + "// The following is equivalent to `approvedAddress = _tokenApproval": 28623, + "} else if (leavesLen > 0) {\\n return leaves[0];\\n } else {\\n return ": 28624, + "root`. For this, a `proof` must be ": 28625, + "For a limit of 5000, a ": 28626, + "root of\\n // the merkle tree.\\n uint256 leavesLen": 28627, + "root hash by traversing the tree up from the leaves. The root is ": 28628, + "BITMASK_ADDRESS = (1 << 160": 28629, + "leaves and each pair of pre-images are assumed to be sorted": 28630, + "full ERC721 compliance, substituting ERC721 ": 28631, + "\\n ) internal pure returns (bytes32 merkleRoot) {\\n // This function rebuil": 28632, + "unrealistic due to the above check for ": 28633, + "proofFlags.length;\\n\\n // Check proof validity": 28634, + "`\\n // - [128..191] `numberBurned`\\n // - [192..255] `aux": 28635, + "`\\n // - [224] `burned`\\n // - [225] `nextInitialized": 28636, + "in a packed ownership except the 24 bits for `": 28637, + "the\\n // `hashes` array. At the ": 28638, + "thus mimicking a queue's \\\"pop": 28639, + "232..255] `extraData": 28640, + "packOwnershipData(address owner, uint256 flags": 28641, + "uint24 extraData = uint24(prevOwnershipPacked ": 28642, + "ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to": 28643, + "uint256(_extraData(from, to, extraData)) ": 28644, + "BITPOS_START_TIMESTAMP) | flags": 28645, + "BITPOS_START_TIMESTAMP, timestamp()), flags": 28646, + "set the 24bit `extraData` field": 28647, + "communitytreasurydao": 28648, + "try ERC721A__IERC721Receiver(to).onERC721Received(_msgSenderERC721A(), from, tokenId, _data) returns (": 28649, + "totalHashes; i++) {\\n bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];\\n bytes32 b = ": 28650, + "\\\" (merging branches) or an element from the\\n // ": 28651, + "hashes[totalHashes - 1": 28652, + "otherwise we\\n // get the next hash.\\n // - ": 28653, + "BITPOS_AUX);\\n _packedAddressData[owner] = packed": 28654, + "BITPOS_NEXT_INITIALIZED, eq(quantity, 1": 28655, + "leaf to the root of the tree. Each\\n * pair of ": 28656, + ".\\n uint256 private _burnCounter;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to ownership details\\n // An empty struct value does not necessarily mean the token is unowned.\\n // ": 28657, + ".\\n uint256 private _currentIndex;\\n\\n // The number of tokens burned.\\n uint256 private _burnCounter;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to ownership details\\n // An empty struct value does not necessarily mean the token is unowned.\\n // ": 28658, + "approvedAddress := sload(approvedAddressSlot": 28659, + "end of the process, the last hash in the `hashes` array should contain the ": 28660, + "xxxPos values are \\\"pointers\\\" to the next value to ": 28661, + "hashPair(a, b);\\n }\\n\\n if (totalHashes ": 28662, + "`balance` and `numberMinted` have a maximum limit of 2**64.": 28663, + "each step, we compute the next hash using two values:\\n // - a value from the \\\"main queue": 28664, + "(proof, proofFlags, leaves) == root": 28665, + "These functions deal with verification of Merkle T": 28666, + "previousExtraData` - the value of `extraData` before ": 28667, + "9e15 calls to ": 28668, + "`proof` array.\\n for (uint256 i = 0; i < totalHashes; i++) {\\n bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];\\n bytes32 b = ": 28669, + "increment the pointer, thus mimicking a queue's \\\"pop": 28670, + "s = 0;\\n uint256 proofPos = 0;\\n // At ": 28671, + "s = 0;\\n uint256 hashPos = 0;\\n uint256 proofPos = 0;\\n // At ": 28672, + "rebuilt by\\n // consuming and producing values on a queue. The queue starts with the ": 28673, + "depending on the flag, either another ": 28674, + "implementation for details.\\n //\\n // Bits Layout:\\n // - [0..159] `addr`\\n // - [160..223] `startTimestamp": 28675, + "`\\n mapping(address => uint256) private _packedAddressData;\\n\\n // Mapping from token ID to approved address.\\n mapping(uint256 => ": 28676, + "intended for efficient minting only ": 28677, + "`leaves` array, then goes onto ": 28678, + "provided, containing\\n * sibling hashes on the branch from the ": 28679, + "limit is to prevent overflows on the address data entries.": 28680, + "creation WILL make your contract": 28681, + "storage slot and value for the approved address ": 28682, + ".\\n *\\n * To select a different value for {decimals}, use {_setupDecimals}.\\n *\\n * All three of these values are immutable: they can only be set once during\\n * construction": 28683, + ".length;\\n uint256 totalHashes = proofFlags.length;\\n\\n // Check proof validity": 28684, + "string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is\\n * called.\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals": 28685, + "Arbitrary data similar to `startTimestamp` that can be set ": 28686, + "MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `": 28687, + "is required to cause an overflow, which is unrealistic": 28688, + "Intended to be overridden by the cosumer contract": 28689, + "It emits only one {ConsecutiveTransfer} as defined ": 28690, + "ed, we get the next leaf, otherwise we\\n // get the next hash.\\n // - ": 28691, + "mask of the lower 160 bits for addresses": 28692, + "Pos++]`, which return the current value and increment the pointer, thus mimicking a queue's \\\"pop": 28693, + "}, initializes {decimals} with\\n * a default value of 18.\\n *\\n * To select a different value for {decimals}, use {_setupDecimals}.\\n *\\n * All three of these values are immutable: they can only be set once during\\n * construction": 28694, + "ed during each token transfer to set the 24bit `extraData` field": 28695, + "bytes32[](totalHashes);\\n uint256 leafPos = 0;\\n uint256 hashPos = 0;\\n uint256 proofPos = 0;\\n // At ": 28696, + "minted with ERC2309 exceeds the safety limit": 28697, + "Calling this function outside of contract creation WILL make your contract": 28698, + "`\\n mapping(uint256 => uint256) private _packedOwnerships;\\n\\n // Mapping owner address to address data.\\n //\\n // Bits Layout:\\n // - [0..63] `balance`\\n // - [64..127] `numberMinted": 28699, + "ConsecutiveTransfer} event is only permissible during contract creation": 28700, + "`quantity` to be below the limit": 28701, + "`nextInitialized` flag set if `quantity` equals 1": 28702, + "\\\".\\n bytes32[] memory hashes = new bytes32[](totalHashes);\\n uint256 leafPos = 0;\\n uint256 hashPos = 0;\\n uint256 proofPos = 0;\\n // At ": 28703, + "\\\". If not all leaves have been consumed, we get the next leaf, otherwise we\\n // get the next hash.\\n // - ": 28704, + "total of 3.689e15 calls to ": 28705, + " == totalHashes, \\\"MerkleProof: invalid multiproof\\\");\\n\\n // The xxxPos values are \\\"pointers\\\" to the next value to ": 28706, + "proof[proofPos++];\\n hashes[i] = _hashPair(a, b);\\n }\\n\\n if (totalHashes ": 28707, + "using\\n // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \\\"pop": 28708, + "For branchless setting of the `nextInitialized` flag": 28709, + "consume in each array. All accesses are done using\\n // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \\\"pop": 28710, + "} else if (leavesLen > 0) {\\n return leaves[0];\\n } else {\\n return proof[0];\\n ": 28711, + "root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the ": 28712, + "For a limit of 5000, a total of 3.689e15 calls to ": 28713, + "root of\\n // the merkle tree.\\n uint256 leavesLen = leaves": 28714, + "root hash by traversing the tree up from the leaves. The root is rebuilt by\\n // consuming and producing values on a queue. The queue starts with the ": 28715, + "leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify": 28716, + "full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309": 28717, + "unrealistic due to the above check for `quantity` to be below the limit": 28718, + "`\\n // - [128..191] `numberBurned`\\n // - [192..255] `aux`\\n mapping(address => uint256) private _packedAddressData;\\n\\n // Mapping from token ID to approved address.\\n mapping(uint256 => ": 28719, + "in a packed ownership except the 24 bits for `extraData": 28720, + "the\\n // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the ": 28721, + "\\\" (merging branches) or an element from the\\n // `proof` array.\\n for (uint256 i = 0; i < totalHashes; i++) {\\n bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];\\n bytes32 b = ": 28722, + "leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify": 28723, + "each step, we compute the next hash using two values:\\n // - a value from the \\\"main queue\\\". If not all leaves have been consumed, we get the next leaf, otherwise we\\n // get the next hash.\\n // - ": 28724, + "previousExtraData` - the value of `extraData` before transfer": 28725, + "implementation for details.\\n //\\n // Bits Layout:\\n // - [0..159] `addr`\\n // - [160..223] `startTimestamp`\\n // - [224] `burned`\\n // - [225] `nextInitialized": 28726, + "`leaves` array, then goes onto the\\n // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the ": 28727, + ".length;\\n uint256 totalHashes = proofFlags.length;\\n\\n // Check proof validity.\\n require(leavesLen + proof": 28728, + "MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the ": 28729, + "`\\n mapping(uint256 => uint256) private _packedOwnerships;\\n\\n // Mapping owner address to address data.\\n //\\n // Bits Layout:\\n // - [0..63] `balance`\\n // - [64..127] `numberMinted`\\n // - [128..191] `numberBurned`\\n // - [192..255] `aux`\\n mapping(address => uint256) private _packedAddressData;\\n\\n // Mapping from token ID to approved address.\\n mapping(uint256 => ": 28730, + "\\\".\\n bytes32[] memory hashes = new bytes32[](totalHashes);\\n uint256 leafPos = 0;\\n uint256 hashPos = 0;\\n uint256 proofPos = 0;\\n // At each step, we compute the next hash using two values:\\n // - a value from the \\\"main queue\\\". If not all leaves have been consumed, we get the next leaf, otherwise we\\n // get the next hash.\\n // - ": 28731, + " == totalHashes, \\\"MerkleProof: invalid multiproof\\\");\\n\\n // The xxxPos values are \\\"pointers\\\" to the next value to consume in each array. All accesses are done using\\n // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \\\"pop": 28732, + "root hash by traversing the tree up from the leaves. The root is rebuilt by\\n // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the\\n // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the ": 28733, + "\\\" (merging branches) or an element from the\\n // `proof` array.\\n for (uint256 i = 0; i < totalHashes; i++) {\\n bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];\\n bytes32 b = proofFlag": 28734, + "MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify": 28735, + "\\\".\\n bytes32[] memory hashes = new bytes32[](totalHashes);\\n uint256 leafPos = 0;\\n uint256 hashPos = 0;\\n uint256 proofPos = 0;\\n // At each step, we compute the next hash using two values:\\n // - a value from the \\\"main queue\\\". If not all leaves have been consumed, we get the next leaf, otherwise we\\n // get the next hash.\\n // - depending on the flag, either another ": 28736, + " == totalHashes, \\\"MerkleProof: invalid multiproof\\\");\\n\\n // The xxxPos values are \\\"pointers\\\" to the next value to consume in each array. All accesses are done using\\n // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \\\"pop\\\".\\n bytes32[] memory hashes = new bytes32[](totalHashes);\\n uint256 leafPos = 0;\\n uint256 hashPos = 0;\\n uint256 proofPos = 0;\\n // At each step, we compute the next hash using two values:\\n // - a value from the \\\"main queue\\\". If not all leaves have been consumed, we get the next leaf, otherwise we\\n // get the next hash.\\n // - depending on the flag, either another ": 28737, + "root hash by traversing the tree up from the leaves. The root is rebuilt by\\n // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the\\n // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of\\n // the merkle tree.\\n uint256 leavesLen = leaves": 28738, + "', v": 28739, + "(##": 28740, + "(2^": 28741, + "(startTokenId, ": 28742, + ")\\n function ": 28743, + ")`,\\n // ": 28744, + ",\\n * ": 28745, + ".\\n /// @param _": 28746, + ".\\n @member ": 28747, + "038": 28748, + "2ee": 28749, + "2) {\\n value /= 10**": 28750, + "2;\\n }\\n if (value >= 10**": 28751, + "3D": 28752, + "3E": 28753, + "4) {\\n value /= 10**": 28754, + "7._\\r\\n */\\r\\n function ": 28755, + "8._\\n */\\n function ": 28756, + "8) {\\n value /= 10**": 28757, + ": ": 28758, + "BR": 28759, + "BreedingEvent": 28760, + "F0": 28761, + "Gov": 28762, + "ISeaDrop(seaDropImpl": 28763, + "KIND": 28764, + "NON": 28765, + "SE": 28766, + "Since": 28767, + "We": 28768, + "WIS": 28769, + "YY": 28770, + "_mem": 28771, + "_Enabled": 28772, + "_WETH": 28773, + "_vault": 28774, + "_blacklist": 28775, + "`keccak256(bytes(\\\"": 28776, + "fy ": 28777, + "s,": 28778, + "ym": 28779, + "\\n uint24 extraData": 28780, + "\\n ) {\\n return retval == ": 28781, + "ink": 28782, + ", input": 28783, + "unblock": 28784, + "\\n * non-compliant with the ERC721 standard": 28785, + "or(owner, ": 28786, + ") << _": 28787, + ") in case of unsuccessful call or if target was not a contract": 28788, + "address) public ": 28789, + "olo": 28790, + "the new ": 28791, + "amask": 28792, + "ing:": 28793, + "\\n bytes4 retval": 28794, + "isContract ": 28795, + "coins": 28796, + "amount * ": 28797, + "\\\"v": 28798, + "\\\"1\\\"": 28799, + "versal": 28800, + "// `tokenId": 28801, + "uint256 packed = _packedOwnerships[": 28802, + "right to ": 28803, + "of two signed ": 28804, + "bool);\\n function ": 28805, + "suffic": 28806, + "or of ": 28807, + "or not": 28808, + "or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {": 28809, + "er = _": 28810, + "transferAndCall": 28811, + ".\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _": 28812, + "stage": 28813, + " = keccak256(bytes(version": 28814, + "chiru": 28815, + ".\\n */\\n function un": 28816, + ".\\n */\\n function mint": 28817, + ",\\n string calldata ": 28818, + "external/": 28819, + ") {\\n (": 28820, + "data.\\n * The ": 28821, + "32) {\\n value /= 10**": 28822, + "\\n let ": 28823, + "sets of ": 28824, + "ayl": 28825, + "Mapping": 28826, + "addBots": 28827, + "msgSender\\n ) private pure returns (": 28828, + "approveAndCall": 28829, + "onlyGovernance": 28830, + "ForLiquidity": 28831, + "16) {\\n value /= 10**": 28832, + "Tokens[": 28833, + "lown": 28834, + "currentSupply": 28835, + "on buy": 28836, + "operator != ": 28837, + "nameHash": 28838, + "name` and `": 28839, + ");\\n\\n unchecked {\\n if (": 28840, + "] > ": 28841, + ";\\n\\n /*//////////////////////////////////////////////////////////////\\n ": 28842, + "MintPrice": 28843, + ").update": 28844, + "targetAddress": 28845, + " packed = _packedOwnerships[--": 28846, + "for(uint ": 28847, + "\\n //": 28848, + "\\n }\\n\\n function ": 28849, + "Siz": 28850, + ") {\\n a = (a * ONE_20) / ": 28851, + "10_000": 28852, + "\\n // `tokenId` has a maximum limit of 2**256": 28853, + "mult": 28854, + "\\\");\\n (bool success, bytes memory returndata) = target.call{value: value}": 28855, + "implements an ": 28856, + "`.\\n ": 28857, + "ized by ": 28858, + "(\\n address approvedAddress": 28859, + ".\\n */\\n function _nextExtraData": 28860, + ".\\n */\\n function _nextInitializedFlag(uint256 quantity": 28861, + ".\\n */\\n function _packOwnershipData(address owner, uint256 flags": 28862, + "buyBack": 28863, + ";\\n sum += x": 28864, + "functionCall} to ": 28865, + "tical ": 28866, + ");\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account": 28867, + "legend": 28868, + "\\n // For a limit of 5000, a total of 3.689e15 calls to ": 28869, + "0, // Start ": 28870, + " != 0, errorMessage": 28871, + ".\\n * Intended to be overridden by the cosumer contract": 28872, + "balance of the ": 28873, + "in the low-level ": 28874, + "in the map": 28875, + "64) {\\n value /= 10**": 28876, + "interface IUniswapV2Factory ": 28877, + "PoolTokens": 28878, + "centiv": 28879, + ");\\n return uint256(_extraData(from, to, extraData)) ": 28880, + ")\\\"),": 28881, + ") external;\\n\\n function ": 28882, + "MetadataURI": 28883, + "\"// SPDX-License-Identifier: MIT\\n// Copyright ": 28884, + "uint256) {\\n uint24 extraData = uint24(prevOwnershipPacked ": 28885, + "uint amount0Out": 28886, + ".\\n assembly {\\n // ": 28887, + "uniswapV2Pair = IUniswapV2Factory": 28888, + "Reset": 28889, + "(tokenId);\\n }\\n\\n /**\\n * @dev ": 28890, + "[] memory proofFlags": 28891, + "s are sequ": 28892, + "(\\n address from,\\n address to,\\n uint256 prevOwnershipPacked": 28893, + ");\\r\\n }\\r\\n ": 28894, + "rewardTracker": 28895, + ".\\n *\\n * _Available since v3.4._": 28896, + ";\\n do {\\n ": 28897, + ";\\n\\n num = (num * z_squared": 28898, + ";\\n\\n term = ((term * x) / ONE_20) / ": 28899, + ";\\n }\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount": 28900, + ");\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {": 28901, + "that is used ": 28902, + "was designed to be ": 28903, + "s for success ": 28904, + "admin_": 28905, + ")\\n internal": 28906, + "Nonblocking": 28907, + "BaseRewardPool": 28908, + "guardian": 28909, + ".\\n */\\n event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to": 28910, + "UpgradeState": 28911, + "() external returns (": 28912, + "price_": 28913, + "amountInWei": 28914, + "also assert": 28915, + ");\\n\\n // The nested ifs save around 20+ gas over a compound boolean condition": 28916, + "Locker": 28917, + "(bytes32 poolId": 28918, + "MinterRemoved": 28919, + "\"contracts/lib/": 28920, + "s.\\n *\\n * _Available since v4.5._": 28921, + "\\n * @param token The token targeted by the call": 28922, + ", which verifies ": 28923, + "interfaces/IERC": 28924, + "cannot send tokens ": 28925, + "spending ": 28926, + "erc4626": 28927, + "restrict": 28928, + "function is intended for efficient minting only ": 28929, + "leafPos": 28930, + "```\\n */\\n function _": 28931, + "Standardiz": 28932, + ".\\n */\\n error OwnershipNotInitializedForExtraData": 28933, + "extraDataCasted;\\n // Cast ": 28934, + "delegateAndReturn": 28935, + "scalar": 28936, + ") external;\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account": 28937, + ") external;\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account": 28938, + "dropURI": 28939, + "rAmount, vestingRound": 28940, + "10**result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base ": 28941, + "10**64) {\\n value /= 10**": 28942, + "check isContract ": 28943, + "(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCallWithValue(target, data": 28944, + "_exists(uint256 tokenId": 28945, + "\\n */\\ninterface IERC2981": 28946, + "5d6": 28947, + "\\n * {ConsecutiveTransfer} event is only permissible during contract creation": 28948, + "See `": 28949, + ", 0, \\\"Address: low-level ": 28950, + "(data, \\\"SafeERC20: ": 28951, + "royalty is owed and to whom": 28952, + "requestRandom": 28953, + "as an immutable ": 28954, + ") external view returns (bool);\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {": 28955, + "uint24) {}\\n\\n /**\\n * @dev ": 28956, + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../Strings.sol\\\";\\n\\n/**\\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\\n *\\n * These functions can be used to verify that a message was signed by the holder\\n * of the private keys of a given address.\\n */\\nlibrary ECDSA {\\n enum RecoverError {\\n NoError,\\n InvalidSignature,\\n InvalidSignatureLength,\\n InvalidSignatureS,\\n InvalidSignatureV": 28957, + ".\\n */\\n constructor() {\\n _paused = false": 28958, + ").interfaceId ||": 28959, + "SharesOut": 28960, + "SharesToRedeem": 28961, + ";\\n // Arbitrary data similar to `startTimestamp` that can be set ": 28962, + "Cached": 28963, + ".\\n *\\n * See {_mint}": 28964, + ".\\n *\\n * _Available since v4.8._\\n */\\n function ": 28965, + "[_pid": 28966, + "\\n // There will always be an ": 28967, + "set of addresses ": 28968, + "Role(role, account);\\n _": 28969, + "(\\n address owner,\\n address operator,\\n bool approved": 28970, + "();\\n\\n /**\\n * The `extraData": 28971, + "();\\n\\n /**\\n * The `quantity` ": 28972, + "`.\\n *\\n * This function is intended for efficient minting only ": 28973, + "));\\n }\\n\\n /**\\n * @dev Return the entire set in an array\\n *\\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\\n */\\n function values(": 28974, + "perform this call": 28975, + "in\\n * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309": 28976, + "bitmap._": 28977, + ".\\n */\\nlibrary MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify": 28978, + "`.\\n ++_packedAddressData[to]; // Updates: `balance += 1`.": 28979, + "Ptr := add(": 28980, + "Revoked} event.\\n */\\n function ": 28981, + ") return (false, 0);\\r\\n ": 28982, + "meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address payable) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes memory": 28983, + "\\\");\\n }\\n return returndata;\\n } else {": 28984, + ") {\\n // The nested ifs save around 20+ gas over a compound boolean condition": 28985, + "Renounced": 28986, + "allPairs(": 28987, + "SafeERC20: approve from non-zero to non-zero allowance": 28988, + "here, ": 28989, + "setFeeTo(address": 28990, + "for more details": 28991, + "sequential ": 28992, + "](https://eips.ethereum.org/EIPS/eip-165": 28993, + "gas.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual ": 28994, + "\\\\x19\\\\x01": 28995, + "ULL": 28996, + ";\\n }\\n if (value >= 10**2) {\\n value /= 10**": 28997, + ";\\n }\\n if (value >= 10**4) {\\n value /= 10**": 28998, + ";\\n }\\n if (value >= 10**8) {\\n value /= 10**": 28999, + ";\\n }\\n if (value >= 10**32) {\\n value /= 10**": 29000, + ";\\n }\\n if (value >= 10**16) {\\n value /= 10**": 29001, + "BITPOS_EXTRA_DATA);\\n return uint256(_extraData(from, to, extraData)) ": 29002, + ".\\n *\\n * `previousExtraData` - the value of `extraData` before transfer": 29003, + "SwapAndLiquifyEnabled": 29004, + "s).\\n *\\n * Calling this function outside of contract creation WILL make your contract": 29005, + ", // Signature": 29006, + "ConsecutiveTransfer} event.\\n */\\n function _mint": 29007, + "ConsecutiveTransfer(startTokenId, ": 29008, + "11/solmate/blob/main/src/": 29009, + "123456789abcdef\"": 29010, + ";\\n\\n // The bit position of `extraData": 29011, + "May not ": 29012, + "),\\n * instead of a sequence of {Transfer} event(": 29013, + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, \\\"ERC20: decreased allowance below zero\\\"));\\n return true;\\n }\\n\\n /**\\n * @dev ": 29014, + ")) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n uint8 private _decimals": 29015, + "Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}.\\n */\\n function isApprovedForAll(address owner, address operator": 29016, + ".sol\\\";\\n\\n/**\\n * @dev Interface for the NFT Royalty Standard": 29017, + "off-chain": 29018, + ".\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n *\\n * May emit a {Role": 29019, + "(to, quantity);\\n\\n unchecked {\\n if (": 29020, + ",\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only ": 29021, + "map._indexes[": 29022, + "0, // End ": 29023, + "BITMASK_NEXT_INITIALIZED) | _nextExtraData": 29024, + "using the provided one) in case of unsuccessful call or if target was not a contract": 29025, + "s `quantity` tokens and transfers them to `to`.\\n *\\n * This function is intended for efficient minting only ": 29026, + "index of the '0' ": 29027, + " _nextExtraData(from, to, prevOwnershipPacked": 29028, + "\\r\\n\\tfunction ": 29029, + "ckpts[": 29030, + "addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(": 29031, + "\"TOKEN: Balance exceeds wallet size": 29032, + " as possible ": 29033, + "BITPOS_NEXT_INITIALIZED`.\\n result := ": 29034, + "data is optional": 29035, + "-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.staticcall": 29036, + ");\\n }\\n }\\n\\n function _revert(bytes memory returndata": 29037, + "(IERC20 token, bytes memory data": 29038, + "low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {": 29039, + "setFeeToSetter(address": 29040, + "index < end);\\n // Reentrancy protection": 29041, + "target address contains contract ": 29042, + "token.allowance(address(this), spender) == 0": 29043, + "IDexFactory": 29044, + "`extraData` with assembly to avoid redundant masking.\\n assembly {\\n ": 29045, + ";\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\\n * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\\n * by default, it can be ": 29046, + ".\\n *\\n * Emits a {ConsecutiveTransfer} event.\\n */\\n function _mint": 29047, + "approvedAddressSlot, address approvedAddress)\\n {\\n ": 29048, + "`.\\n result := or(": 29049, + "` to the lower 160 bits, in case the upper bits somehow aren't clean.\\n msgSender := and(msgSender": 29050, + "validate the ": 29051, + "`.\\n _packedAddressData[from] += ": 29052, + ", address[] calldata path, address to, uint deadline)\\n external\\n returns (": 29053, + ", address[] calldata path, address to, uint deadline)\\n external\\n payable\\n returns (": 29054, + "address(0xdead), true": 29055, + "(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or ": 29056, + "(address,address,uint256)\\\"))": 29057, + "Type == ": 29058, + "\\n view\\n ": 29059, + "];\\n if (packed ": 29060, + ") | (extraDataCasted ": 29061, + "32;\\n result += 32;\\n }\\n if (value >= 10**16) {\\n value /= 10**": 29062, + "64;\\n result += 64;\\n }\\n if (value >= 10**32) {\\n value /= 10**": 29063, + "(\\n address sender,\\n address recipient,\\n uint256 amount\\n ) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer": 29064, + ";\\n }\\n\\n /**\\n * @dev Called during each token transfer to set the 24bit `extraData` field": 29065, + ",\\n bytes32 root,\\n bytes32[] memory leaves": 29066, + "ASCII index of the '0' ": 29067, + ".\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `quantity` must be greater than 0.\\n *\\n * Emits a {ConsecutiveTransfer} event.\\n */\\n function _mint": 29068, + ");\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), ": 29069, + "_TRANSFER_EVENT_SIGNATURE, // Signature": 29070, + "Indicates ": 29071, + "10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log256(value);\\n return result + (rounding == Rounding.Up && 1 << (": 29072, + "creator payout ": 29073, + "\\n ) private view returns (uint256) {\\n uint24 extraData = uint24(prevOwnershipPacked ": 29074, + "ERC2309QuantityExceedsLimit();\\n\\n /**\\n * The `extraData": 29075, + "_EXTRA_DATA_COMPLEMENT) | (extraDataCasted ": 29076, + "_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) external view returns (bytes32": 29077, + "2;\\n result += 2;\\n }\\n if (value >= 10**": 29078, + "Globals": 29079, + ");\\n\\n /**\\n * @dev Revert with an error if the ": 29080, + "frozenAccount": 29081, + "fraction of the ": 29082, + ",\\n bool[] memory proofFlags": 29083, + "during contract creation.\\n *\\n * ": 29084, + "address signer = ECDSA.recover(digest": 29085, + "startTokenId + quantity;\\n }\\n _afterTokenTransfers(address(0), to, startTokenId, quantity": 29086, + "COLLATERAL": 29087, + ";\\n\\n // Mask of all 256 bits in a packed ownership except the 24 bits for `extraData": 29088, + "AccessControl-_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account": 29089, + "AccessControl-_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) external view returns (bytes32": 29090, + "The divisor cannot be zero.\\r\\n */\\r\\n function ": 29091, + "zroPaymentAddress": 29092, + "do {\\n emit Transfer(address(0), to, updatedIndex": 29093, + "(\\n bytes32[] memory proof,\\n bool[] memory proofFlags": 29094, + ") - 1;\\n\\n // The maximum `quantity` that can be minted ": 29095, + ") - 1;\\n\\n // The mask of the lower 160 bits for addresses": 29096, + "Casted;\\n // Cast `aux": 29097, + "\\\",\\n Strings.toHexString": 29098, + "\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a ": 29099, + "\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata": 29100, + ",\\n bytes32[] memory leaves\\n ) internal pure returns (bytes32 merkleRoot) {\\n // This function rebuil": 29101, + "format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\\n */\\n function _checkRole(bytes32 role, address account": 29102, + "format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _check": 29103, + "` with assembly to avoid redundant masking.\\n assembly {\\n auxCasted := aux": 29104, + ",\\n bytes memory _data\\n ) internal virtual {\\n _mint(to, tokenId);\\n require(\\n _checkOnERC721Received": 29105, + ".\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, `tokenId` will be burned by `from`.\\n * - `from` and `to` are never both zero.\\n */\\n function _extraData(\\n address from,\\n address to,\\n uint24 previousExtraData": 29106, + "path[1] = uniswapV2Router.WETH": 29107, + "Project ID": 29108, + "toMasked, // ": 29109, + "how much royalty is owed and to whom": 29110, + ") external view returns (address pair);\\n function ": 29111, + "(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.staticcall": 29112, + "Abstract": 29113, + ": amount exceeds 96 bits\"": 29114, + ", string memory errorMessage) private pure {\\n // Look for revert reason and bubble it up if present\\n if (": 29115, + ".sol\\\";\\n\\nimport { ": 29116, + "EIP712 message ": 29117, + "returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n ": 29118, + "(address _from, address _to": 29119, + "IERC721Receiver-onERC721Received}, which is called for each safe transfer.\\n * - `quantity` must be greater than 0.\\n *\\n * See {_mint}": 29120, + "Return data is optional": 29121, + "`account`.\\n *\\n * Internal function without access restriction.\\n *\\n * May emit a {Role": 29122, + ";\\n }\\n ": 29123, + "start time of ownership with minimal overhead for tokenomics.\\n uint64 startTimestamp;\\n // Whether the token has been burned.\\n bool burned;\\n // Arbitrary data similar to `startTimestamp` that can be set ": 29124, + "_balances[sender] = senderBalance - amount;\\n }\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount": 29125, + "trustedRemoteLookup": 29126, + "cannot exceed 2**256 - 1 (max value of uint256).\\n */\\ncontract ERC721A is IERC721A": 29127, + "(\\n uint256 a,\\n uint256 b,\\n string memory errorMessage\\n ) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return ": 29128, + "\\n unchecked {\\n return _currentIndex - _startTokenId();\\n }\\n }\\n\\n /**\\n * @dev Returns the total number of tokens burned.\\n */\\n function _totalBurned(": 29129, + "data[bucket": 29130, + ";\\n uint256 index = end - quantity": 29131, + "(sender, recipient, amount);\\n _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, \\\"ERC20: transfer amount exceeds allowance\\\"));\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)": 29132, + "startTokenId() <= tokenId &&\\n ": 29133, + ".\\n */\\n error MintERC2309QuantityExceedsLimit();\\n\\n /**\\n * The `extraData": 29134, + "\\n // This limit is to prevent overflows on the address data entries.": 29135, + "WARE": 29136, + " > 0) {\\r\\n value >>= ": 29137, + ");\\n _roles[role].adminRole = adminRole;\\n emit RoleAdminChanged(role, previousAdminRole, adminRole": 29138, + "16;\\n result += 16;\\n }\\n if (value >= 10**8) {\\n value /= 10**": 29139, + "4;\\n result += 4;\\n }\\n if (value >= 10**2) {\\n value /= 10**": 29140, + "8;\\n result += 8;\\n }\\n if (value >= 10**4) {\\n value /= 10**": 29141, + "1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base ": 29142, + ") internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> 2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= 10**64) {\\n value /= 10**": 29143, + "\"//SPDX-License-Identifier: MIT": 29144, + "`newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {AccessControl-_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account": 29145, + ", address(0), to": 29146, + "(address pair, bool value": 29147, + "Role(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n bytes32 previousAdminRole = getRoleAdmin(role": 29148, + "return\\n _startTokenId() <= tokenId &&\\n ": 29149, + "FictiveReserve": 29150, + "https://forum.openzeppelin.com/": 29151, + "Modified from ": 29152, + "_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(": 29153, + "(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, \\\"ERC20: transfer amount exceeds allowance\\\"));\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)": 29154, + "Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n assembly {\\n size := extcodesize(account)\\n }\\n return size > 0": 29155, + ";\\n seriesSum += term;\\n\\n term = ((term * x) / ONE_20) / ": 29156, + "ERC721Receiver interface.\\n */\\n error TransferToNonERC721ReceiverImplementer();\\n\\n /**\\n * Cannot transfer to the zero address.\\n */\\n error TransferToZeroAddress();\\n\\n /**\\n * The token does not exist.\\n */\\n error URIQueryForNonexistentToken();\\n\\n /**\\n * The `quantity` ": 29157, + "end, str": 29158, + "transmissions11/solmate/blob/main/src/": 29159, + "Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n _balances[sender] = _balances[sender].sub(amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[recipient] = _balances[recipient].add(amount);\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` ": 29160, + "uint256 end = _currentIndex": 29161, + "signed 64.64-bit ": 29162, + "bool isApprovedOrOwner = (_msgSender() == ": 29163, + "return packed;\\n }\\n ": 29164, + "utils/Context.sol\\\";\\nimport \\\"../utils/Strings.sol\\\";\\nimport \\\"../": 29165, + "Mask `to": 29166, + ");\\n\\n if (approvalCheck) {\\n // The nested ifs save around 20+ gas over a compound boolean condition": 29167, + "\\n ) internal view virtual returns (uint24) {}\\n\\n /**\\n * @dev ": 29168, + "code and also assert": 29169, + "isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {": 29170, + "BITPOS_NUMBER_BURNED;`.\\n _packedAddressData[from] += ": 29171, + "BITMASK_NEXT_INITIALIZED = 1 << 225;\\n\\n // The bit position of `extraData": 29172, + "' and '": 29173, + "return _currentIndex - _burnCounter - _startTokenId();\\n }\\n }\\n\\n /**\\n * @dev Returns the total amount of tokens minted in the contract.\\n */\\n function _totalMinted(": 29174, + "\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {": 29175, + "),\\n \\\" is missing role \\\",\\n Strings.": 29176, + "We need to perform a low level call here, to bypass Solidity's ": 29177, + "--_packedAddressData[from]; // Updates: `balance -= 1`.\\n ++_packedAddressData[to]; // Updates: `balance += 1`.": 29178, + "setExtraDataAt(uint256 index, uint24 extraData": 29179, + "setupDecimals(uint8 decimals_": 29180, + "Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(": 29181, + "prettier-ignore\\n for { let temp := ": 29182, + "Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\\n */\\n function _checkRole(bytes32 role, address account": 29183, + "on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call": 29184, + "ApprovalForAll} event.\\n */\\n function _setApprovalForAll(\\n address owner,\\n address operator,\\n bool approved": 29185, + ");\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account": 29186, + "verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only ": 29187, + "Equivalent to `_burn(tokenId, false)`.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n _burn(tokenId, false);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId, bool approvalCheck) internal virtual {\\n uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);\\n\\n address from = address(uint160(prevOwnershipPacked));\\n\\n ": 29188, + "Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _check": 29189, + "if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {": 29190, + "decimals() external pure returns (uint8": 29191, + ".\\n * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309": 29192, + ", \\\"ERC721: approve to caller\\\");\\n _operatorApprovals[owner][operator] = approved;\\n emit ApprovalForAll(owner, operator, approved);\\n }\\n\\n /**\\n * @dev ": 29193, + "character is 48": 29194, + "owner != operator, \\\"ERC721: approve to caller\\\");\\n _operatorApprovals[owner][operator] = approved;\\n emit ApprovalForAll(owner, operator, approved);\\n }\\n\\n /**\\n * @dev ": 29195, + "IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Enumerable is IERC721 {\\n /**\\n * @dev Returns the total amount of tokens stored by the contract.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns a token ID owned by `owner` at a given `index` of its token list.\\n * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.\\n */\\n function tokenOfOwnerByIndex(address owner, uint256 index": 29196, + " bits\\r\\n *\\r\\n * _Available since v4.7._\\r\\n */\\r\\n function ": 29197, + "Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControl is Context, IAccessControl, ERC165 {\\n struct RoleData {\\n ": 29198, + "implementing it ourselves. We use {": 29199, + ");\\n if (to.code.length != 0)\\n if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {\\n revert TransferToNonERC721ReceiverImplementer();\\n ": 29200, + "uint256) {\\n // Counter underflow is impossible as _burnCounter cannot be incremented\\n // more than `_currentIndex - _startTokenId()` times.\\n unchecked {\\n return _currentIndex - _burnCounter - _startTokenId();\\n }\\n }\\n\\n /**\\n * @dev Returns the total amount of tokens minted in the contract.\\n */\\n function _totalMinted(": 29201, + "if (!hasRole(role, account)) {\\n revert(\\n string(\\n abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n Strings.toHexString": 29202, + "\\n\\n // Updates:\\n // - `address` to the next owner.\\n // - `startTimestamp` to the timestamp of transfering.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `true`.\\n _packedOwnerships[tokenId": 29203, + ".\\n unchecked {\\n // We can directly increment and decrement the balances.\\n --_packedAddressData[from]; // Updates: `balance -= 1`.\\n ++_packedAddressData[to]; // Updates: `balance += 1`.": 29204, + "BITPOS_NUMBER_BURNED) - 1;\\n\\n // Updates:\\n // - `address` to the last owner.\\n // - `startTimestamp` to the timestamp of burning.\\n // - `burned` to `true`.\\n // - `nextInitialized` to `true`.\\n _packedOwnerships[tokenId": 29205, + "\"0123456789abcdef\"": 29206, + "This account cannot send tokens ": 29207, + " != 0;\\n ownership.extraData = uint24(": 29208, + "`index`.\\n */\\n function _setExtraDataAt(uint256 index, uint24 extraData": 29209, + "BITPOS_EXTRA_DATA = 232;\\n\\n // Mask of all 256 bits in a packed ownership except the 24 bits for `extraData": 29210, + "value == 0) || (token.allowance(address(this), spender) == 0": 29211, + "BITMASK_NEXT_INITIALIZED | _nextExtraData(from, to, prevOwnershipPacked": 29212, + "startTokenId + quantity - 1, address(0), to": 29213, + "Mask `msgSender` to the lower 160 bits, in case the upper bits somehow aren't clean.\\n msgSender := and(msgSender": 29214, + "_EXTRA_DATA_COMPLEMENT = (1 << 232) - 1;\\n\\n // The mask of the lower 160 bits for addresses": 29215, + "MAX_MINT_ERC2309_QUANTITY_LIMIT = 5000;\\n\\n // The ": 29216, + "extra data for the packed ownership data.\\n * The ": 29217, + "msgSender == approvedAddress`.\\n result := or(": 29218, + "bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: ": 29219, + "Directly sets the extra data for the ownership data `index`.\\n */\\n function _setExtraDataAt(uint256 index, uint24 extraData": 29220, + "Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call": 29221, + "Packs ownership data into a single uint256.\\n */\\n function _packOwnershipData(address owner, uint256 flags": 29222, + "` cannot be set on an unintialized ownership slot.\\n */\\n error OwnershipNotInitializedForExtraData": 29223, + "returned result is shifted into position.\\n */\\n function _nextExtraData": 29224, + "BITMASK_ADDRESS = (1 << 160) - 1;\\n\\n // The maximum `quantity` that can be minted ": 29225, + "BITPOS_START_TIMESTAMP) | flags`.\\n result := ": 29226, + "BITPOS_NEXT_INITIALIZED, eq(quantity, 1))\\n ": 29227, + "approvedAddress := sload(approvedAddressSlot)\\n ": 29228, + "`balance` and `numberMinted` have a maximum limit of 2**64.\\n // `tokenId` has a maximum limit of 2**256": 29229, + "storage slot and value for the approved address of `tokenId`.\\n */\\n function _": 29230, + "It emits only one {ConsecutiveTransfer} as defined in\\n * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309": 29231, + "minted with ERC2309 exceeds the safety limit.\\n */\\n error MintERC2309QuantityExceedsLimit();\\n\\n /**\\n * The `extraData": 29232, + "`nextInitialized` flag set if `quantity` equals 1.\\n */\\n function _nextInitializedFlag(uint256 quantity": 29233, + "', vrAmount, vestingRound": 29234, + "\\n * non-compliant with the ERC721 standard.\\n * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309": 29235, + "or(owner, or(": 29236, + "\\n bytes4 retval\\n ) {\\n return retval == ": 29237, + "chiru-": 29238, + "msgSender\\n ) private pure returns (bool result": 29239, + "\\\");\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.staticcall": 29240, + "functionCall} to perform this call": 29241, + ");\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account": 29242, + ".\\n * Intended to be overridden by the cosumer contract.\\n *\\n * `previousExtraData` - the value of `extraData` before transfer": 29243, + "in the low-level call": 29244, + "(\\n address from,\\n address to,\\n uint256 prevOwnershipPacked\\n ) private view returns (uint256) {\\n uint24 extraData = uint24(prevOwnershipPacked ": 29245, + "s for success in the low-level call": 29246, + ", which verifies that": 29247, + "Standardized": 29248, + "extraDataCasted;\\n // Cast `extraData` with assembly to avoid redundant masking.\\n assembly {\\n ": 29249, + ") external;\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\"": 29250, + "check isContract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {": 29251, + "(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, \\\"Address: low-level ": 29252, + "\\n * {ConsecutiveTransfer} event is only permissible during contract creation.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `quantity` must be greater than 0.\\n *\\n * Emits a {ConsecutiveTransfer} event.\\n */\\n function _mint": 29253, + ") external view returns (bool);\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {AccessControl-_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) external view returns (bytes32": 29254, + ".\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only ": 29255, + "bitmap._data[bucket": 29256, + ") return (false, 0);\\r\\n return (true, ": 29257, + "for more details.\\n */\\n event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to": 29258, + "s).\\n *\\n * Calling this function outside of contract creation WILL make your contract\\n * non-compliant with the ERC721 standard.\\n * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309": 29259, + "ConsecutiveTransfer(startTokenId, startTokenId + quantity - 1, address(0), to": 29260, + "),\\n * instead of a sequence of {Transfer} event(s).\\n *\\n * Calling this function outside of contract creation WILL make your contract\\n * non-compliant with the ERC721 standard.\\n * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309": 29261, + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, \\\"ERC20: decreased allowance below zero\\\"));\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n _balances[sender] = _balances[sender].sub(amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[recipient] = _balances[recipient].add(amount);\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` ": 29262, + "(to, quantity);\\n\\n unchecked {\\n if (to.code.length != 0) {\\n ": 29263, + "BITMASK_NEXT_INITIALIZED) | _nextExtraData(from, address(0), prevOwnershipPacked": 29264, + "using the provided one) in case of unsuccessful call or if target was not a contract.\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only ": 29265, + "s `quantity` tokens and transfers them to `to`.\\n *\\n * This function is intended for efficient minting only during contract creation.\\n *\\n * ": 29266, + "\"TOKEN: Balance exceeds wallet size!\"": 29267, + "low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata": 29268, + "index < end);\\n // Reentrancy protection.\\n if (": 29269, + "target address contains contract code and also assert": 29270, + ";\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\\n * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\\n * by default, it can be overridden in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return ": 29271, + ", address[] calldata path, address to, uint deadline)\\n external\\n returns (uint[] memory amounts);\\n function ": 29272, + "(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only ": 29273, + "32;\\n result += 32;\\n }\\n if (value >= 10**16) {\\n value /= 10**16;\\n result += 16;\\n }\\n if (value >= 10**8) {\\n value /= 10**": 29274, + "64;\\n result += 64;\\n }\\n if (value >= 10**32) {\\n value /= 10**32;\\n result += 32;\\n }\\n if (value >= 10**16) {\\n value /= 10**16;\\n result += 16;\\n }\\n if (value >= 10**8) {\\n value /= 10**": 29275, + ";\\n }\\n\\n /**\\n * @dev Called during each token transfer to set the 24bit `extraData` field.\\n * Intended to be overridden by the cosumer contract.\\n *\\n * `previousExtraData` - the value of `extraData` before transfer": 29276, + ",\\n bytes32 root,\\n bytes32[] memory leaves\\n ) internal pure returns (bool) {\\n return ": 29277, + "ASCII index of the '0' character is 48": 29278, + "2;\\n result += 2;\\n }\\n if (value >= 10**1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base ": 29279, + "Casted;\\n // Cast `aux` with assembly to avoid redundant masking.\\n assembly {\\n auxCasted := aux": 29280, + "\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata": 29281, + ",\\n bytes memory _data\\n ) internal virtual {\\n _mint(to, tokenId);\\n require(\\n _checkOnERC721Received(address(0), to, tokenId, _data": 29282, + ".\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, `tokenId` will be burned by `from`.\\n * - `from` and `to` are never both zero.\\n */\\n function _extraData(\\n address from,\\n address to,\\n uint24 previousExtraData\\n ) internal view virtual returns (uint24) {}\\n\\n /**\\n * @dev ": 29283, + ", string memory errorMessage) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n ": 29284, + "IERC721Receiver-onERC721Received}, which is called for each safe transfer.\\n * - `quantity` must be greater than 0.\\n *\\n * See {_mint}.\\n *\\n * Emits a {Transfer} event for each mint.\\n */\\n function _safeMint(\\n address to,\\n uint256 quantity": 29285, + "cannot exceed 2**256 - 1 (max value of uint256).\\n */\\ncontract ERC721A is IERC721A {\\n // ": 29286, + ";\\n uint256 index = end - quantity;\\n do {\\n ": 29287, + "\\n // This limit is to prevent overflows on the address data entries.\\n // For a limit of 5000, a total of 3.689e15 calls to ": 29288, + "4;\\n result += 4;\\n }\\n if (value >= 10**2) {\\n value /= 10**2;\\n result += 2;\\n }\\n if (value >= 10**1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base ": 29289, + "8;\\n result += 8;\\n }\\n if (value >= 10**4) {\\n value /= 10**4;\\n result += 4;\\n }\\n if (value >= 10**2) {\\n value /= 10**2;\\n result += 2;\\n }\\n if (value >= 10**1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base ": 29290, + ") internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> 2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= 10**64) {\\n value /= 10**64;\\n result += 64;\\n }\\n if (value >= 10**32) {\\n value /= 10**32;\\n result += 32;\\n }\\n if (value >= 10**16) {\\n value /= 10**16;\\n result += 16;\\n }\\n if (value >= 10**8) {\\n value /= 10**": 29291, + "`newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {AccessControl-_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {AccessControl-_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) external view returns (bytes32": 29292, + "Role(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n bytes32 previousAdminRole = getRoleAdmin(role);\\n _roles[role].adminRole = adminRole;\\n emit RoleAdminChanged(role, previousAdminRole, adminRole": 29293, + "(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, \\\"ERC20: transfer amount exceeds allowance\\\"));\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, \\\"ERC20: decreased allowance below zero\\\"));\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n _balances[sender] = _balances[sender].sub(amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[recipient] = _balances[recipient].add(amount);\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` ": 29294, + "ERC721Receiver interface.\\n */\\n error TransferToNonERC721ReceiverImplementer();\\n\\n /**\\n * Cannot transfer to the zero address.\\n */\\n error TransferToZeroAddress();\\n\\n /**\\n * The token does not exist.\\n */\\n error URIQueryForNonexistentToken();\\n\\n /**\\n * The `quantity` minted with ERC2309 exceeds the safety limit.\\n */\\n error MintERC2309QuantityExceedsLimit();\\n\\n /**\\n * The `extraData": 29295, + "utils/Context.sol\\\";\\nimport \\\"../utils/Strings.sol\\\";\\nimport \\\"../utils/introspection/ERC165.sol\\\";\\n\\n/**\\n * @dev ": 29296, + ".\\n unchecked {\\n // We can directly increment and decrement the balances.\\n --_packedAddressData[from]; // Updates: `balance -= 1`.\\n ++_packedAddressData[to]; // Updates: `balance += 1`.\\n\\n // Updates:\\n // - `address` to the next owner.\\n // - `startTimestamp` to the timestamp of transfering.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `true`.\\n _packedOwnerships[tokenId": 29297, + "This account cannot send tokens until trading is ": 29298, + "extra data for the packed ownership data.\\n * The returned result is shifted into position.\\n */\\n function _nextExtraData": 29299, + "bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed": 29300, + "Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The ": 29301, + "` cannot be set on an unintialized ownership slot.\\n */\\n error OwnershipNotInitializedForExtraData();\\n\\n ": 29302, + "It emits only one {ConsecutiveTransfer} as defined in\\n * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309),\\n * instead of a sequence of {Transfer} event(s).\\n *\\n * Calling this function outside of contract creation WILL make your contract\\n * non-compliant with the ERC721 standard.\\n * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309": 29303, + "', vrAmount, vestingRound1": 29304, + "functionCall} to perform this call, which verifies that": 29305, + ");\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\"": 29306, + "extraDataCasted;\\n // Cast `extraData` with assembly to avoid redundant masking.\\n assembly {\\n extraDataCasted := extraData": 29307, + "check isContract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata": 29308, + "\\n * {ConsecutiveTransfer} event is only permissible during contract creation.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `quantity` must be greater than 0.\\n *\\n * Emits a {ConsecutiveTransfer} event.\\n */\\n function _mintERC2309": 29309, + "s `quantity` tokens and transfers them to `to`.\\n *\\n * This function is intended for efficient minting only during contract creation.\\n *\\n * It emits only one {ConsecutiveTransfer} as defined in\\n * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309),\\n * instead of a sequence of {Transfer} event(s).\\n *\\n * Calling this function outside of contract creation WILL make your contract\\n * non-compliant with the ERC721 standard.\\n * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309": 29310, + "target address contains contract code and also asserts for success in the low-level call": 29311, + "(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only check isContract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata": 29312, + ";\\n }\\n\\n /**\\n * @dev Called during each token transfer to set the 24bit `extraData` field.\\n * Intended to be overridden by the cosumer contract.\\n *\\n * `previousExtraData` - the value of `extraData` before transfer.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, `tokenId` will be burned by `from`.\\n * - `from` and `to` are never both zero.\\n */\\n function _extraData(\\n address from,\\n address to,\\n uint24 previousExtraData\\n ) internal view virtual returns (uint24) {}\\n\\n /**\\n * @dev ": 29313, + ", string memory errorMessage) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage": 29314, + "8;\\n result += 8;\\n }\\n if (value >= 10**4) {\\n value /= 10**4;\\n result += 4;\\n }\\n if (value >= 10**2) {\\n value /= 10**2;\\n result += 2;\\n }\\n if (value >= 10**1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log256(value);\\n return result + (rounding == Rounding.Up && 1 << (": 29315, + ") internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> 2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= 10**64) {\\n value /= 10**64;\\n result += 64;\\n }\\n if (value >= 10**32) {\\n value /= 10**32;\\n result += 32;\\n }\\n if (value >= 10**16) {\\n value /= 10**16;\\n result += 16;\\n }\\n if (value >= 10**8) {\\n value /= 10**8;\\n result += 8;\\n }\\n if (value >= 10**4) {\\n value /= 10**4;\\n result += 4;\\n }\\n if (value >= 10**2) {\\n value /= 10**2;\\n result += 2;\\n }\\n if (value >= 10**1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log256(value);\\n return result + (rounding == Rounding.Up && 1 << (": 29316, + "`newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {AccessControl-_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {AccessControl-_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\"": 29317, + "ERC721Receiver interface.\\n */\\n error TransferToNonERC721ReceiverImplementer();\\n\\n /**\\n * Cannot transfer to the zero address.\\n */\\n error TransferToZeroAddress();\\n\\n /**\\n * The token does not exist.\\n */\\n error URIQueryForNonexistentToken();\\n\\n /**\\n * The `quantity` minted with ERC2309 exceeds the safety limit.\\n */\\n error MintERC2309QuantityExceedsLimit();\\n\\n /**\\n * The `extraData` cannot be set on an unintialized ownership slot.\\n */\\n error OwnershipNotInitializedForExtraData();\\n\\n ": 29318, + "extra data for the packed ownership data.\\n * The returned result is shifted into position.\\n */\\n function _nextExtraData(\\n address from,\\n address to,\\n uint256 prevOwnershipPacked\\n ) private view returns (uint256) {\\n uint24 extraData = uint24(prevOwnershipPacked ": 29319, + "s `quantity` tokens and transfers them to `to`.\\n *\\n * This function is intended for efficient minting only during contract creation.\\n *\\n * It emits only one {ConsecutiveTransfer} as defined in\\n * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309),\\n * instead of a sequence of {Transfer} event(s).\\n *\\n * Calling this function outside of contract creation WILL make your contract\\n * non-compliant with the ERC721 standard.\\n * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309\\n * {ConsecutiveTransfer} event is only permissible during contract creation.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `quantity` must be greater than 0.\\n *\\n * Emits a {ConsecutiveTransfer} event.\\n */\\n function _mintERC2309": 29320, + "(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only check isContract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata, string memory errorMessage) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage": 29321, + " implementation ": 29322, + " should be ": 29323, + "!swapping": 29324, + ".\\n\\n": 29325, + "/sign": 29326, + "@4.": 29327, + "Ape": 29328, + "Bad": 29329, + "Benefici": 29330, + "DApp": 29331, + "High": 29332, + "Mail": 29333, + "Tayl": 29334, + "UUP": 29335, + "XOR": 29336, + "[hashed ": 29337, + "_ERC721": 29338, + "_version": 29339, + "_cooldown": 29340, + "`values": 29341, + "baf": 29342, + "bid ": 29343, + "c6": 29344, + "d8": 29345, + "e, and the ": 29346, + "ge ": 29347, + "hind ": 29348, + "ide ": 29349, + "len ": 29350, + "pxCVX": 29351, + "ring": 29352, + "sit": 29353, + "s)\\\"),": 29354, + "x <= ": 29355, + "y_": 29356, + "{\\r\\n": 29357, + "}\\n }\\n": 29358, + "enci": 29359, + "\\n (bool success, ) = recipient.call{ value: amount ": 29360, + "in\\n // the ": 29361, + ", string calldata ": 29362, + "acy": 29363, + "\\n * applications that interact with token contracts will not expect": 29364, + "address's ": 29365, + "ing\\n * https://": 29366, + "tokenOut ": 29367, + "end;\\n }\\n _afterTokenTransfers(address(0), to, startTokenId, quantity);\\n }\\n\\n /**\\n * @dev Mint": 29368, + "isOperatorFilte": 29369, + "ic, and ": 29370, + "a xref:": 29371, + "ToSubscribe": 29372, + "owner, \\\"": 29373, + "asible": 29374, + "context ": 29375, + "devAddress": 29376, + "imm": 29377, + "TokenOwner": 29378, + " //\\n// ": 29379, + "OwnerTo": 29380, + "calling the ": 29381, + "an owner ": 29382, + "- The maximum ": 29383, + "Transfer(address,address,uint256)\\\"))": 29384, + "=========": 29385, + " = 40": 29386, + " = set._indexes[value": 29387, + "shuff": 29388, + "in `": 29389, + ") internal override {\\n ": 29390, + ". Protocol": 29391, + ". In ": 29392, + "InWei": 29393, + "} instead": 29394, + "set.\\n ": 29395, + "sets]": 29396, + "totalBuyFees": 29397, + " to delete with the last ": 29398, + "AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(": 29399, + "... ": 29400, + "Support": 29401, + " of primitive": 29402, + "by `": 29403, + "require(msg.sender == ": 29404, + "as efficient": 29405, + "value to the index where the ": 29406, + "party ": 29407, + "behind ": 29408, + "Forced": 29409, + "contract upgrade": 29410, + "OfFiltered": 29411, + "a sale ": 29412, + "(uint256 _mintAmount": 29413, + "token type `id": 29414, + "s.\\n function ": 29415, + "The implementation of the ": 29416, + ";\\n\\nabstract contract ": 29417, + "operator is not ": 29418, + "name`: ": 29419, + ";\\n\\n /* ": 29420, + "import {\\n ": 29421, + ").\\r\\n *\\r\\n * ": 29422, + " ({_": 29423, + "bytes32 last": 29424, + "will make the ": 29425, + "WithCode": 29426, + "balanceOf[from": 29427, + "_AR": 29428, + "iler will ": 29429, + "contents)\\\"),": 29430, + "\\n // will ": 29431, + " of the encod": 29432, + "] = set._values.length": 29433, + "safeApprove ": 29434, + "Index - 1;\\n uint256 lastIndex = ": 29435, + "`.\\n *\\n * This ": 29436, + "`amounts` ": 29437, + ";\\n address ": 29438, + ".\\n */\\n function _setupDecimals(uint8 decimals_": 29439, + "buyfeeRate.": 29440, + "hash of ": 29441, + "hashstruct": 29442, + ";\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev ": 29443, + "0.8.0 <0.9.0": 29444, + "transferFrom(address sender, address recipient, uint256 amount": 29445, + ")))": 29446, + "IDeleg": 29447, + "Set_(": 29448, + "Set;\\n * }\\n * ```\\n *\\n * As of ": 29449, + "Set.\\n // This means that we can only create new ": 29450, + "set values\\n ": 29451, + "abi.encode` and `": 29452, + "ASE": 29453, + " for the current ": 29454, + "balance -= 1;\\n ": 29455, + "mainRouter": 29456, + "Ownable.sol\"": 29457, + "scra": 29458, + "is not fe": 29459, + "interface is ": 29460, + "PoolManager": 29461, + ")\\n uint256 ": 29462, + "ain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall": 29463, + "will be zero": 29464, + "Pause ": 29465, + "add(Set storage set, bytes32 value) private returns (bool) {\\n ": 29466, + "\"@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol\"": 29467, + "_values array ": 29468, + "::upgrad": 29469, + "EnabledTrading": 29470, + "_tx": 29471, + "has issues ": 29472, + "manually ": 29473, + " - start": 29474, + "uint256) {\\n return set._values.length": 29475, + " and parameter ": 29476, + "Admin(": 29477, + "AdminChanged": 29478, + "signed via ": 29479, + "ed in their ": 29480, + "need in their ": 29481, + "traits": 29482, + "(uint256 tokenId)\\n private\\n view\\n returns (uint256 ": 29483, + "one in\\n // the ": 29484, + "Timestamp = ": 29485, + ".\\n *\\n * Sets ": 29486, + "OO_": 29487, + "delBots": 29488, + "Set type with\\n // bytes32 ": 29489, + "Set implementation uses private functions, and user-facing\\n // implementations (such as ": 29490, + "generic, and ": 29491, + "that is then ": 29492, + "s for this ": 29493, + "version`: ": 29494, + "true if the ": 29495, + "() == ": 29496, + "\\n // solhint-disable-next-line no-inline-assembly": 29497, + "recover} to ": 29498, + ") internal view virtual returns (uint256) {\\n return ": 29499, + "(value);\\n // The ": 29500, + "type-specific ": 29501, + "they need in their ": 29502, + "the current major ": 29503, + "UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(": 29504, + "already has ": 29505, + "greater ": 29506, + "tokenId = ": 29507, + "struct], ": 29508, + "Locks": 29509, + "(bytes32 structHash": 29510, + "tokenA,\\r\\n address ": 29511, + "signer of a ": 29512, + "{IERC20-approve}.": 29513, + "_data_type": 29514, + "can be used together with {": 29515, + "abstract_data_type": 29516, + ") external view returns (uint256);\\n\\n function ": 29517, + "AllowedSeaDrop": 29518, + "containing ": 29519, + "Set storage set, uint256 index) private view returns (": 29520, + "Transfers `tokenId` from `from` to `to": 29521, + "royalty-": 29522, + "/\\n function ": 29523, + "Access ": 29524, + "contracts using a ": 29525, + "Can only ": 29526, + "`) are supported": 29527, + "values on the set. O(1": 29528, + "\\n * {decimals} to ever change, and may work incorrectly if it does": 29529, + "Fee / ": 29530, + "value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n ": 29531, + "hash can be used together with {": 29532, + "rewardsCycle": 29533, + "ing to obtain the ": 29534, + "ing.\\n // The ": 29535, + "Started(": 29536, + "manager ": 29537, + ",\\r\\n uint256 ": 29538, + ", as implemented by the ": 29539, + "IsActive": 29540, + "implementation in Solidity ": 29541, + "-contracts.adoc[": 29542, + "votes for ": 29543, + "{IERC20-approve}, and its ": 29544, + "around the\\n // ": 29545, + "html[`eth_sign": 29546, + ".\\n * @dev ": 29547, + ".\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract": 29548, + "(), structHash": 29549, + "Initializes the domain separator": 29550, + "name of the signing domain": 29551, + "name of the DApp": 29552, + "index 0\\n // ": 29553, + ")) {\\n revert ": 29554, + ")) {\\n set._values": 29555, + "keccak256(\\\"Mail": 29556, + "uint256, uint256, ": 29557, + "ing of typed structured ": 29558, + "guide/sign": 29559, + "element (": 29560, + "element to delete with the last ": 29561, + "means a value ": 29562, + "name = \\\"": 29563, + ") private view returns (uint256 result": 29564, + "ing-smart": 29565, + "ing-data.": 29566, + "EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct ": 29567, + "successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract": 29568, + ", uint256 index) internal view returns (uint256) {\\n return ": 29569, + "super._mint": 29570, + "UserBalance": 29571, + "such a generic ": 29572, + "\"@1inch/": 29573, + "SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token": 29574, + "specified in the EIP": 29575, + "(\\r\\n address tokenA,\\r\\n address ": 29576, + "Wrapped ": 29577, + "AddressSet\\n\\n struct ": 29578, + "AddressSet) are just wrappers ": 29579, + "emitted when ": 29580, + "filteredOperator": 29581, + "filteredOperators": 29582, + "exceed max ": 29583, + "_setupRole(": 29584, + "possible, use {": 29585, + "randomness ": 29586, + "value was stored\\n ": 29587, + "test/": 29588, + "at(Set storage set, uint256 index) private view returns (": 29589, + "` (`AddressSet": 29590, + "domain separator ({_": 29591, + "domain separator for the current ": 29592, + "allow list": 29593, + "reduces ": 29594, + "copyEntries": 29595, + "copyExisting": 29596, + "launchBlock": 29597, + "in the set. O(1).\\n */\\n function _contains(": 29598, + "MerkleProof.sol\"": 29599, + " = valueIndex - 1;\\n uint256 lastIndex = ": 29600, + "rights": 29601, + "Compiler will ": 29602, + "BptIn": 29603, + "be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract": 29604, + "contracts@4.": 29605, + ") private pure returns (uint256 result) {\\n // ": 29606, + "Equivalent to contains(set, value": 29607, + ")\\n internal\\n view\\n returns (": 29608, + "s on an event": 29609, + ". This function has issues ": 29610, + "Handl": 29611, + "unicode\\\"": 29612, + ". To increase and decrease ": 29613, + "ECDSA-recover} to ": 29614, + "step of the encod": 29615, + "}\\r\\n\\r\\n\\tfunction ": 29616, + "_sellFee": 29617, + "thus this contract does not ": 29618, + "NOTE: This contract implements the ": 29619, + "set._values.length - 1": 29620, + "set._values.pop(": 29621, + "Private": 29622, + "TypedDataV4` in ": 29623, + "voting power history ": 29624, + "underlying Set.\\n // This means that we can only create new ": 29625, + "{\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic ": 29626, + "Set storage set, bytes32 value) private view returns (bool) {\\n return ": 29627, + "tokenOfOwnerByIndex}.\\n */\\n function ": 29628, + "calculateInvariant(": 29629, + "until the ": 29630, + "keccak256(bytes(mail": 29631, + "{_hashTypedDataV4": 29632, + "protect against replay attack": 29633, + "(address to,string ": 29634, + "AddressSet storage set, uint256 index) internal view returns (address) {\\n return ": 29635, + "UintSet storage set, uint256 index) internal view returns (uint256) {\\n return ": 29636, + "}) that is used ": 29637, + "\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(": 29638, + "hash of the fully ": 29639, + "number of tokens in `owner`'s ": 29640, + "BooleanSlot": 29641, + "itself. Protocol": 29642, + "Loaned": 29643, + "domain separator was designed to be ": 29644, + "UintSet`) are supported": 29645, + "UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(": 29646, + "for this domain": 29647, + "These parameters ": 29648, + "returns the hash of the fully ": 29649, + "hashTypedDataV4(bytes32 structHash": 29650, + ";\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}, initializes {decimals} with\\n * a default value of 18.\\n *\\n * To select a different value for {decimals}, use {_setupDecimals}.\\n *\\n * All three of these values are immutable: they can only be set once during\\n * construction": 29651, + "domainSeparatorV4(), structHash": 29652, + "domainSeparatorV4}) that is used ": 29653, + "tokenByIndex}.\\n */\\n function ": 29654, + "ERC721A__IERC721Receiver(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert TransferToNonERC721ReceiverImplementer();\\n } else {\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n ": 29655, + "stashVersion": 29656, + "https://eips.ethereum.org/EIPS/eip-712[EIP 712]": 29657, + ".length - 1 == totalHashes, \\\"MerkleProof: invalid multiproof\\\");\\n\\n // The xxxPos values are \\\"pointers\\\" to the next value to consume in each array. All accesses are done using\\n // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \\\"pop\\\".\\n bytes32[] memory hashes = new bytes32[](totalHashes);\\n uint256 leafPos = 0;\\n uint256 hashPos = 0;\\n uint256 proofPos = 0;\\n // At each step, we compute the next hash using two values:\\n // - a value from the \\\"main queue\\\". If not all leaves have been consumed, we get the next leaf, otherwise we\\n // get the next hash.\\n // - depending on the flag, either another ": 29658, + "ual fork": 29659, + "unks": 29660, + "encoding known as ": 29661, + "encoding specified in the EIP": 29662, + "encoding itself. Protocol": 29663, + "valueIndex != 0": 29664, + "valueIndex = set._indexes[value": 29665, + "final step of the encod": 29666, + "encoded EIP712 message ": 29667, + "explicitOwnerships": 29668, + "message. For example": 29669, + " from the _values array ": 29670, + "MetaMask": 29671, + "initialized ownership slot": 29672, + "set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of ": 29673, + "set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev ": 29674, + "set._indexes[value] = set._values.length": 29675, + "] = _packOwnershipData(\\n from,\\n ": 29676, + "Set {\\n // Storage of ": 29677, + "Returns true if the value is in the set. O(1).\\n */\\n function _contains(": 29678, + "Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(": 29679, + ";\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _": 29680, + "result * 8": 29681, + "\"TOKEN: Max Transaction ": 29682, + "\"TOKEN: This account cannot send tokens until trading is ": 29683, + "GSN/Context": 29684, + "`address` (`AddressSet": 29685, + "Whenever possible, use {": 29686, + "should only be called when setting ": 29687, + "Max wallet exceeded": 29688, + ".io/guide/sign": 29689, + "function selector of `": 29690, + "docs.met": 29691, + "it, use": 29692, + "value to delete is": 29693, + "Contents))": 29694, + "skim(address to": 29695, + "safeIncreaseAllowance} ": 29696, + "safeDecreaseAllowance} instead": 29697, + "Artblocks": 29698, + "transfer from the zero address\\\");\\r\\n require(": 29699, + ",\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc": 29700, + ")\\n if (!isApprovedForAll(owner, _msgSenderERC721A())": 29701, + ") internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev ": 29702, + ") internal view returns (bool) {\\n return _contains(set._inner, bytes32(value": 29703, + "set._values[lastIndex": 29704, + "set._values[toDeleteIndex] = ": 29705, + "AddressSet storage set, address value) internal returns (bool) {\\n return _remove(": 29706, + "AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(": 29707, + "AddressSet storage set, address value) internal returns (bool) {\\n return _add(": 29708, + "UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(": 29709, + "UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev ": 29710, + "UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value": 29711, + "implement the type-specific ": 29712, + "implement the encoding itself. Protocol": 29713, + "security/Pausable.sol\"": 29714, + "combination of `": 29715, + ");\\n\\n _afterTokenTransfer(sender, recipient, amount": 29716, + "mailTo": 29717, + " is a standard for ": 29718, + "Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(": 29719, + "Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value": 29720, + "Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(": 29721, + "Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev ": 29722, + ".push(value);\\n // The ": 29723, + "(\\r\\n address from,\\r\\n address to,\\r\\n uint256 tokenId": 29724, + "splitting the ": 29725, + "value in the `values": 29726, + "(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes memory _data\\n ) private returns (bool) {\\n try ERC721A__IERC721Receiver(to).onERC721Received(_msgSenderERC721A(), from, tokenId, _data) returns (": 29727, + "if (!_contains(set, value": 29728, + " because index 0\\n // ": 29729, + ", \\\"SafeERC20: decreased allowance below zero": 29730, + "an element from the _values array ": 29731, + "ADMIN_ROLE": 29732, + "== 0) revert OwnershipNotInitializedForExtraData": 29733, + "version of the signing domain": 29734, + "version of the encoding known as ": 29735, + "usage is discourag": 29736, + ".\\n *\\n * WARNING: This function should only be called from the constructor. Most": 29737, + "];\\n\\n if (valueIndex != 0": 29738, + "TRANSFER_EVENT_SIGNATUR": 29739, + "string memory name, string memory version": 29740, + "into a single 256bit ": 29741, + "except through a xref:": 29742, + "string memory _name,\\n string memory _symbol": 29743, + "obtain the signer of a ": 29744, + ");\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set": 29745, + "https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct": 29746, + "contract implements the EIP 712 ": 29747, + "isCodeHashFiltered": 29748, + "isCodeHashOfFiltered": 29749, + "subscribers": 29750, + "filteredCodeHashes": 29751, + "Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the ": 29752, + "Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - ": 29753, + "set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev ": 29754, + "\\n@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@": 29755, + "else {\\n ": 29756, + ");\\n\\n // Clear approvals from the previous owner.\\n assembly {\\n if approvedAddress {\\n // This is equivalent to `delete _tokenApprovals[tokenId]`.\\n sstore(approvedAddressSlot, 0)\\n }\\n }\\n\\n // Underflow of the sender's balance is impossible because we check for\\n // ownership above and the recipient's balance can't realistically overflow.\\n // Counter overflow is incredibly unrealistic as `tokenId` would have to be 2**256.\\n unchecked {\\n // Updates:\\n // - `balance -= 1`.\\n // - `numberBurned += 1`.\\n //\\n // We can directly decrement the balance, and increment the number burned.\\n // This is equivalent to `packed -= 1; packed += 1": 29757, + "WHITE": 29758, + "EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * ": 29759, + "token/ERC721/IERC721.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes calldata data\\n ) external;\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to": 29760, + "_exists(nextTokenId": 29761, + "Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\"": 29762, + "Given an already ": 29763, + "properly updating": 29764, + "cheduled": 29765, + "path[0] = address(this);\\n ": 29766, + "scratch spac": 29767, + "can use this function.\\n *\\n * @param seaDropImpl": 29768, + "EnumerableSet.AddressSet private my": 29769, + "the user readable ": 29770, + "Set storage set) private view returns (uint256) {\\n return set._values.length": 29771, + "(owner(), true": 29772, + "Library for managing\\n * https://": 29773, + "string memory) {\\n if (!_exists(tokenId)) revert URIQueryForNonexistentToken();\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, _toString(tokenId))) : ''": 29774, + "emporarilyPausable": 29775, + "WALLE": 29776, + "\\n * contract returns false). Tokens that return no value (and instead revert ": 29777, + "`, as defined in ": 29778, + ");\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(\\n address to,\\n uint256 tokenId,\\n bytes memory _data\\n ) internal virtual {\\n _mint(to, tokenId);\\n require(\\n _checkOnERC721Received(address(0), to, tokenId, _data": 29779, + "IERC20[] memory tokens": 29780, + "Solmate (https://github.com/transmissions11/solmate/blob/main/src/": 29781, + "en.wikipedia.org/wiki/Set_(": 29782, + "decimals = decimals_;\\n }\\n\\n /**\\n * @dev ": 29783, + "\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes memory _data\\n ": 29784, + "Administrator": 29785, + "at any point": 29786, + "an initial allowance": 29787, + "scheme, and the ": 29788, + "is not in the set.\\n ": 29789, + "emit OwnershipTransferred(_owner, newOwner);\\n _owner = newOwner": 29790, + ")[sets]": 29791, + "while still properly updating": 29792, + "Optimized for ": 29793, + "Deprecated. This function has issues ": 29794, + "bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc": 29795, + "JOIN": 29796, + "ones found ": 29797, + "bytes32[] _values": 29798, + "for {\\n let ": 29799, + "(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance": 29800, + "_msgSenderERC721A() != owner)\\n if (!isApprovedForAll(owner, _msgSenderERC721A())": 29801, + "s need to implement the type-specific ": 29802, + "message digest that is then ": 29803, + "\\n // If the address is zero, packed ": 29804, + ";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with GSN meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address payable) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes memory": 29805, + "similar to the ones found ": 29806, + "ustodian": 29807, + "or when resetting ": 29808, + "values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as ": 29809, + "address[] memory path = new address[](2);\\n path[0] = address(this);\\n ": 29810, + ")\\n // To delete an element from the _values array ": 29811, + "Position of the value in the `values": 29812, + ").\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length": 29813, + "Move the last value to the index where the ": 29814, + "uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _": 29815, + "have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - ": 29816, + "in O(1), we swap the element to delete with the last ": 29817, + "array, and then remove the last element (": 29818, + "Update the index for the moved value": 29819, + "` array, plus 1 because index 0\\n // ": 29820, + "Delete the slot where the moved value was stored\\n ": 29821, + ");\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev ": 29822, + "4\\\", as implemented by the ": 29823, + "or\\n * throw on failure) are also supported, non-reverting calls are assumed to ": 29824, + "\\n * types.\\n *\\n * Sets ": 29825, + "cannot be changed except through a xref:": 29826, + "version` is specified ": 29827, + "meaning of `name` and `": 29828, + ");\\n\\n if (address(uint160(prevOwnershipPacked)) != from) revert TransferFromIncorrectOwner();\\n\\n ": 29829, + "it to zero. To increase and decrease ": 29830, + "// solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount ": 29831, + "JSON RPC method": 29832, + "Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n */\\ninterface IERC20Permit {\\n /**\\n * @dev Sets `value` as the allowance of `spender` ": 29833, + ".\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator\\n ) internal pure returns (uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0))\\n prod0 := mul(x, y)\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1 == 0) {\\n return prod0 / denominator;\\n }\\n\\n // Make sure the result is less than 2^256. Also prevents denominator == 0.\\n require(denominator > prod1);\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator)\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder)\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function.\\n uint256 twos = denominator & (~denominator + 1);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1)\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step.\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator,\\n Rounding rounding\\n ) internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> 2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= 10**64) {\\n value /= 10**64;\\n result += 64;\\n }\\n if (value >= 10**32) {\\n value /= 10**32;\\n result += 32;\\n }\\n if (value >= 10**16) {\\n value /= 10**16;\\n result += 16;\\n }\\n if (value >= 10**8) {\\n value /= 10**8;\\n result += 8;\\n }\\n if (value >= 10**4) {\\n value /= 10**4;\\n result += 4;\\n }\\n if (value >= 10**2) {\\n value /= 10**2;\\n result += 2;\\n }\\n if (value >= 10**1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log256(value);\\n return result + (rounding == Rounding.Up && 1 << (": 29834, + "hashing and signing of typed structured ": 29835, + "Sets {decimals} to a value other than the default one of 18.\\n *\\n * WARNING: This function should only be called from the constructor. Most": 29836, + " is very generic, and ": 29837, + "learn::upgrad": 29838, + "_currentIndex != end) revert(": 29839, + "DefaultRoyalty(address receiver, uint96 feeNumerator": 29840, + "chain id to protect against replay attack": 29841, + "bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(": 29842, + ", i.e. the name of the DApp": 29843, + "prettier-ignore\\n if iszero(temp) { break ": 29844, + "// Stores the ": 29845, + "SwapTokensThreshold": 29846, + " or the protocol": 29847, + "auxiliary data for `owner`. (e.g. number of whitelist mint slots used).\\n */\\n function _getAux(address owner) internal view returns (uint64) {\\n return uint64": 29848, + "https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]": 29849, + "} 1 {} {\\n str := sub(str": 29850, + "mapping(address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping(bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _check": 29851, + "(_packedOwnerships[index]);\\n }\\n\\n /**\\n * @dev Initializes the ownership slot minted at `index` for efficiency purposes.\\n */\\n function _initializeOwnershipAt(uint256 index": 29852, + "spendAllowance(account, _msgSender(), amount);\\n ": 29853, + "from rightmost digit to leftmost digit.\\n // The following is essentially a do-while loop that also handles the zero case.\\n // ": 29854, + "For branchless setting of the `nextInitialized` flag.\\n assembly {\\n // ": 29855, + ".length;\\n uint256 totalHashes = proofFlags.length;\\n\\n // Check proof validity.\\n require(leavesLen + proof.length - 1 == totalHashes, \\\"MerkleProof: invalid multiproof\\\");\\n\\n // The xxxPos values are \\\"pointers\\\" to the next value to consume in each array. All accesses are done using\\n // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \\\"pop\\\".\\n bytes32[] memory hashes = new bytes32[](totalHashes);\\n uint256 leafPos = 0;\\n uint256 hashPos = 0;\\n uint256 proofPos = 0;\\n // At each step, we compute the next hash using two values:\\n // - a value from the \\\"main queue\\\". If not all leaves have been consumed, we get the next leaf, otherwise we\\n // get the next hash.\\n // - depending on the flag, either another ": 29856, + "root hash by traversing the tree up from the leaves. The root is rebuilt by\\n // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the\\n // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of\\n // the merkle tree.\\n uint256 leavesLen = leaves.length;\\n uint256 totalHashes = proofFlags.length;\\n\\n // Check proof validity.\\n require(leavesLen + proof.length - 1 == totalHashes, \\\"MerkleProof: invalid multiproof\\\");\\n\\n // The xxxPos values are \\\"pointers\\\" to the next value to consume in each array. All accesses are done using\\n // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \\\"pop\\\".\\n bytes32[] memory hashes = new bytes32[](totalHashes);\\n uint256 leafPos = 0;\\n uint256 hashPos = 0;\\n uint256 proofPos = 0;\\n // At each step, we compute the next hash using two values:\\n // - a value from the \\\"main queue\\\". If not all leaves have been consumed, we get the next leaf, otherwise we\\n // get the next hash.\\n // - depending on the flag, either another ": 29857, + "`keccak256(bytes(\\\"Transfer(address,address,uint256)\\\"))": 29858, + "amask.io/guide/sign": 29859, + "\\\"v4\\\", as implemented by the ": 29860, + "uint256 packed = _packedOwnerships[curr]": 29861, + " packed = _packedOwnerships[--curr]": 29862, + ");\\n\\n // The nested ifs save around 20+ gas over a compound boolean condition.\\n ": 29863, + " as possible while still properly updating": 29864, + "address signer = ECDSA.recover(digest, signature": 29865, + ");\\n\\n if (approvalCheck) {\\n // The nested ifs save around 20+ gas over a compound boolean condition.\\n ": 29866, + "),\\n \\\" is missing role \\\",\\n Strings.toHexString(uint256(role), 32)\\n )\\n )\\n );\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role": 29867, + "prettier-ignore\\n for { let temp := value ": 29868, + "ApprovalForAll} event.\\n */\\n function _setApprovalForAll(\\n address owner,\\n address operator,\\n bool approved\\n ) internal virtual {\\n require(": 29869, + "BITPOS_START_TIMESTAMP) | flags`.\\n result := or(owner, or(": 29870, + "`nextInitialized` flag set if `quantity` equals 1.\\n */\\n function _nextInitializedFlag(uint256 quantity) private pure returns (uint256 result) {\\n // ": 29871, + ";\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\\n * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\\n * by default, it can be overridden in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return ''": 29872, + "ASCII index of the '0' character is 48.\\n mstore8(": 29873, + ";\\n uint256 index = end - quantity;\\n do {\\n if (!_checkContractOnERC721Received(address(0), to, index": 29874, + "(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only check isContract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata, string memory errorMessage) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n}\\n\"": 29875, + "[hashed struct], ": 29876, + "\\n * applications that interact with token contracts will not expect\\n * {decimals} to ever change, and may work incorrectly if it does": 29877, + "end;\\n }\\n _afterTokenTransfers(address(0), to, startTokenId, quantity);\\n }\\n\\n /**\\n * @dev Mints `quantity` tokens and transfers them to `to`.\\n *\\n * This function is intended for efficient minting only during contract creation.\\n *\\n * It emits only one {ConsecutiveTransfer} as defined in\\n * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309),\\n * instead of a sequence of {Transfer} event(s).\\n *\\n * Calling this function outside of contract creation WILL make your contract\\n * non-compliant with the ERC721 standard.\\n * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309\\n * {ConsecutiveTransfer} event is only permissible during contract creation.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `quantity` must be greater than 0.\\n *\\n * Emits a {ConsecutiveTransfer} event.\\n */\\n function _mintERC2309": 29878, + "isOperatorFiltered": 29879, + "AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(": 29880, + " of primitive\\n * types.\\n *\\n * Sets ": 29881, + "as efficient as possible while still properly updating": 29882, + "The implementation of the domain separator was designed to be ": 29883, + "name`: the user readable ": 29884, + "safeApprove should only be called when setting ": 29885, + ";\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(": 29886, + "set values\\n bytes32[] _values": 29887, + "abi.encode` and `keccak256": 29888, + "is not feasible": 29889, + "add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value": 29890, + " and parameter caches": 29891, + "signed via ECDSA": 29892, + "(uint256 tokenId)\\n private\\n view\\n returns (uint256 approvedAddressSlot, address approvedAddress)\\n {\\n ": 29893, + "one in\\n // the array, and then remove the last element (": 29894, + "Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as ": 29895, + "version`: the current major ": 29896, + "they need in their contracts using a ": 29897, + "abstract_data_type)[sets]": 29898, + "values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length": 29899, + "value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length": 29900, + "hash can be used together with {ECDSA-recover} to ": 29901, + "ing to obtain the message digest that is then ": 29902, + "implementation in Solidity is not feasible": 29903, + "{IERC20-approve}, and its usage is discourag": 29904, + "around the\\n // underlying Set.\\n // This means that we can only create new ": 29905, + "html[`eth_signTypedDataV4` in ": 29906, + "Initializes the domain separator and parameter caches": 29907, + "name of the signing domain, i.e. the name of the DApp": 29908, + ")) {\\n set._values.push(value);\\n // The ": 29909, + "keccak256(\\\"Mail(address to,string ": 29910, + "means a value is not in the set.\\n ": 29911, + "ing-smart-contracts.adoc[": 29912, + "ing-data.html[`eth_signTypedDataV4` in ": 29913, + "EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of ": 29914, + "such a generic implementation in Solidity is not feasible": 29915, + "SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert ": 29916, + "(\\r\\n address tokenA,\\r\\n address tokenB": 29917, + "AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(": 29918, + "AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new ": 29919, + "domain separator ({_domainSeparatorV4}) that is used ": 29920, + "domain separator for the current chain": 29921, + "copyEntriesOf": 29922, + "copyExistingEntries": 29923, + " = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1": 29924, + "be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc": 29925, + "Equivalent to contains(set, value)\\n // To delete an element from the _values array ": 29926, + "s on an eventual fork": 29927, + "thus this contract does not implement the encoding itself. Protocol": 29928, + "NOTE: This contract implements the version of the encoding known as ": 29929, + "set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev ": 29930, + "{\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as ": 29931, + "Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of ": 29932, + "keccak256(bytes(mailContents))": 29933, + "UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index": 29934, + "UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(": 29935, + "These parameters cannot be changed except through a xref:": 29936, + "returns the hash of the fully encoded EIP712 message ": 29937, + "hashTypedDataV4(bytes32 structHash) internal view virtual returns (": 29938, + "https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for ": 29939, + "encoding specified in the EIP is very generic, and ": 29940, + "valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0": 29941, + "final step of the encoding to obtain the message digest that is then ": 29942, + "message. For example:": 29943, + "Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of ": 29944, + "\"TOKEN: Max Transaction Limit\"": 29945, + "\"TOKEN: This account cannot send tokens until trading is enabled\"": 29946, + "Whenever possible, use {safeIncreaseAllowance} ": 29947, + "docs.metamask.io/guide/sign": 29948, + "combination of `abi.encode` and `keccak256": 29949, + "Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value)": 29950, + "(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes memory _data\\n ) private returns (bool) {\\n try ERC721A__IERC721Receiver(to).onERC721Received(_msgSenderERC721A(), from, tokenId, _data) returns (\\n bytes4 retval\\n ) {\\n return retval == ": 29951, + "into a single 256bit word": 29952, + "obtain the signer of a message. For example:": 29953, + "https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], ": 29954, + "contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used ": 29955, + "Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value": 29956, + "set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value)": 29957, + "EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private my": 29958, + "Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], ": 29959, + "Library for managing\\n * https://en.wikipedia.org/wiki/Set_(": 29960, + "scheme, and the final step of the encoding to obtain the message digest that is then ": 29961, + "Deprecated. This function has issues similar to the ones found ": 29962, + "or when resetting it to zero. To increase and decrease ": 29963, + "Position of the value in the `values` array, plus 1 because index 0\\n // ": 29964, + "Move the last value to the index where the value to delete is": 29965, + "uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value": 29966, + "have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are ": 29967, + "in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (": 29968, + "Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev ": 29969, + "or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc": 29970, + "meaning of `name` and `version` is specified ": 29971, + ".\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator\\n ) internal pure returns (uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0))\\n prod0 := mul(x, y)\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1 == 0) {\\n return prod0 / denominator;\\n }\\n\\n // Make sure the result is less than 2^256. Also prevents denominator == 0.\\n require(denominator > prod1);\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator)\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder)\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function.\\n uint256 twos = denominator & (~denominator + 1);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1)\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step.\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator,\\n Rounding rounding\\n ) internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> 2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= 10**64) {\\n value /= 10**64;\\n result += 64;\\n }\\n if (value >= 10**32) {\\n value /= 10**32;\\n result += 32;\\n }\\n if (value >= 10**16) {\\n value /= 10**16;\\n result += 16;\\n }\\n if (value >= 10**8) {\\n value /= 10**8;\\n result += 8;\\n }\\n if (value >= 10**4) {\\n value /= 10**4;\\n result += 4;\\n }\\n if (value >= 10**2) {\\n value /= 10**2;\\n result += 2;\\n }\\n if (value >= 10**1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log256(value);\\n return result + (rounding == Rounding.Up && 1 << (result * 8": 29972, + "hashing and signing of typed structured data": 29973, + "Sets {decimals} to a value other than the default one of 18.\\n *\\n * WARNING: This function should only be called from the constructor. Most\\n * applications that interact with token contracts will not expect\\n * {decimals} to ever change, and may work incorrectly if it does": 29974, + "learn::upgrading-smart-contracts.adoc[": 29975, + "chain id to protect against replay attacks on an eventual fork": 29976, + "For branchless setting of the `nextInitialized` flag.\\n assembly {\\n // `(quantity == 1": 29977, + "\\\"v4\\\", as implemented by the JSON RPC method": 29978, + " of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are ": 29979, + "The implementation of the domain separator was designed to be as efficient as possible while still properly updating": 29980, + "name`: the user readable name of the signing domain, i.e. the name of the DApp": 29981, + "safeApprove should only be called when setting an initial allowance": 29982, + ";\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value": 29983, + "version`: the current major version of the signing domain": 29984, + "they need in their contracts using a combination of `abi.encode` and `keccak256": 29985, + "abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are ": 29986, + "value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value": 29987, + "hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:": 29988, + ")) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value": 29989, + "keccak256(\\\"Mail(address to,string contents)\\\"),": 29990, + "ing-data.html[`eth_signTypedDataV4` in MetaMask": 29991, + "EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values": 29992, + "SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc": 29993, + "AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values": 29994, + "Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (": 29995, + "thus this contract does not implement the encoding itself. Protocols need to implement the type-specific ": 29996, + "NOTE: This contract implements the version of the encoding known as \\\"v4\\\", as implemented by the JSON RPC method": 29997, + "{\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values": 29998, + "UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value)": 29999 + }, + "merges": [ + [ + " ", + " " + ], + [ + " ", + " " + ], + [ + "\\", + "n" + ], + [ + "\\n", + " " + ], + [ + "r", + "e" + ], + [ + "n", + "t" + ], + [ + "e", + "r" + ], + [ + "a", + "l" + ], + [ + "e", + " " + ], + [ + "s", + " " + ], + [ + "e", + "n" + ], + [ + "i", + "nt" + ], + [ + " ", + "*" + ], + [ + "t", + "o" + ], + [ + "o", + "n" + ], + [ + "\\n ", + " " + ], + [ + "t", + "h" + ], + [ + "t", + "i" + ], + [ + "a", + "d" + ], + [ + "a", + "n" + ], + [ + "i", + "n" + ], + [ + "re", + "s" + ], + [ + "\\n ", + " *" + ], + [ + "d", + "res" + ], + [ + "t", + "u" + ], + [ + "u", + "int" + ], + [ + "ad", + "dres" + ], + [ + "ti", + "on" + ], + [ + ",", + " " + ], + [ + "e", + "d" + ], + [ + "o", + "u" + ], + [ + "t", + " " + ], + [ + "r", + "o" + ], + [ + "r", + "n" + ], + [ + "u", + "n" + ], + [ + "2", + "5" + ], + [ + "25", + "6" + ], + [ + "a", + "c" + ], + [ + "/", + "/" + ], + [ + "tu", + "rn" + ], + [ + "d", + "e" + ], + [ + "uint", + "256" + ], + [ + "=", + "=" + ], + [ + "ou", + "nt" + ], + [ + "c", + "tion" + ], + [ + "re", + "turn" + ], + [ + "\\n *", + " " + ], + [ + "f", + "un" + ], + [ + "o", + "r" + ], + [ + "fun", + "ction" + ], + [ + "k", + "en" + ], + [ + "e", + "s" + ], + [ + ")", + " " + ], + [ + "addres", + "s" + ], + [ + "t", + "r" + ], + [ + "o", + "l" + ], + [ + "th", + "e " + ], + [ + "a", + "t" + ], + [ + "o", + "w" + ], + [ + "a", + "m" + ], + [ + "b", + "l" + ], + [ + "in", + "g" + ], + [ + "al", + "l" + ], + [ + "n", + "er" + ], + [ + "p", + "p" + ], + [ + "y", + " " + ], + [ + ")", + ";" + ], + [ + "to", + "ken" + ], + [ + "e", + "nt" + ], + [ + "er", + "n" + ], + [ + "ern", + "al" + ], + [ + "en", + "d" + ], + [ + "i", + "t" + ], + [ + "\\n ", + " " + ], + [ + "e", + "x" + ], + [ + "i", + "s" + ], + [ + "a", + "r" + ], + [ + "*", + "*" + ], + [ + "c", + "o" + ], + [ + "e", + "m" + ], + [ + "i", + "c" + ], + [ + "v", + "i" + ], + [ + "ed", + " " + ], + [ + "=", + " " + ], + [ + "am", + "ount" + ], + [ + "f", + " " + ], + [ + "an", + "c" + ], + [ + "E", + "R" + ], + [ + "s", + "e" + ], + [ + "q", + "u" + ], + [ + "\\", + "\"" + ], + [ + "an", + "s" + ], + [ + "end", + "er" + ], + [ + "f", + "er" + ], + [ + "\\", + "r" + ], + [ + "v", + "al" + ], + [ + "function", + " " + ], + [ + "ro", + "m" + ], + [ + "p", + "u" + ], + [ + "ER", + "C" + ], + [ + "i", + "s " + ], + [ + "ans", + "fer" + ], + [ + "==", + "==" + ], + [ + "v", + "er" + ], + [ + ".", + "\\n *" + ], + [ + "e", + "w" + ], + [ + "to", + " " + ], + [ + "addres", + "s " + ], + [ + "a", + " " + ], + [ + "\\n", + "\\n " + ], + [ + "qu", + "i" + ], + [ + "T", + "o" + ], + [ + "//", + " " + ], + [ + "`", + " " + ], + [ + "u", + "e" + ], + [ + "uint256", + " " + ], + [ + "ow", + "ner" + ], + [ + "ex", + "t" + ], + [ + "a", + "s" + ], + [ + "d", + " " + ], + [ + "r", + "ac" + ], + [ + "f", + "rom" + ], + [ + "co", + "nt" + ], + [ + "e", + "t" + ], + [ + "ing", + " " + ], + [ + "e", + "c" + ], + [ + "r", + "i" + ], + [ + "de", + "v" + ], + [ + "/", + "**" + ], + [ + "o", + "ol" + ], + [ + "o", + "f " + ], + [ + "0", + "0" + ], + [ + "qui", + "re" + ], + [ + "@", + "dev" + ], + [ + "\\n", + " *" + ], + [ + "i", + "m" + ], + [ + "@dev", + " " + ], + [ + "u", + "s" + ], + [ + "\\n ", + "function " + ], + [ + "\\n ", + "}" + ], + [ + "O", + "w" + ], + [ + "s", + "tr" + ], + [ + ":", + " " + ], + [ + "bl", + "ic" + ], + [ + "ernal", + " " + ], + [ + "al", + "anc" + ], + [ + "I", + "d" + ], + [ + "pu", + "blic" + ], + [ + "to", + "r" + ], + [ + "y", + "t" + ], + [ + "To", + "ken" + ], + [ + "pp", + "ro" + ], + [ + ") ", + "{" + ], + [ + "a", + "bl" + ], + [ + "ac", + "c" + ], + [ + "vi", + "ew" + ], + [ + "b", + "yt" + ], + [ + "cont", + "rac" + ], + [ + "b", + "ool" + ], + [ + "d", + "at" + ], + [ + "s", + "u" + ], + [ + "e", + "l" + ], + [ + "2", + "0" + ], + [ + "m", + "a" + ], + [ + "s ", + "(" + ], + [ + "m", + "em" + ], + [ + "i", + "p" + ], + [ + "R", + "e" + ], + [ + "n", + "o" + ], + [ + "/**", + "\\n * " + ], + [ + "mem", + "or" + ], + [ + " ", + " " + ], + [ + "Ow", + "ner" + ], + [ + "w", + "a" + ], + [ + "re", + "quire" + ], + [ + "return", + "s (" + ], + [ + "or", + " " + ], + [ + "a", + "g" + ], + [ + "return", + "s" + ], + [ + "er", + " " + ], + [ + ".", + "s" + ], + [ + "acc", + "ount" + ], + [ + "\\n }", + "\\n\\n " + ], + [ + "T", + "r" + ], + [ + "c", + "all" + ], + [ + "tr", + "ansfer" + ], + [ + "l", + "e" + ], + [ + "e", + "e" + ], + [ + "ERC", + "20" + ], + [ + "m", + "s" + ], + [ + "/**\\n * ", + "@dev " + ], + [ + "/", + "\\n function " + ], + [ + "u", + "l" + ], + [ + "s", + "p" + ], + [ + "l", + "y" + ], + [ + "an", + " " + ], + [ + "i", + "f" + ], + [ + "l", + "o" + ], + [ + "b", + "alanc" + ], + [ + "v", + "e" + ], + [ + "//", + "//" + ], + [ + ".\\n *", + "\\n * " + ], + [ + "-", + " " + ], + [ + "s", + "t" + ], + [ + "re", + " " + ], + [ + "b", + "e " + ], + [ + "s", + "i" + ], + [ + "val", + "ue" + ], + [ + "Tr", + "ansfer" + ], + [ + "ms", + "g" + ], + [ + "====", + "====" + ], + [ + "l", + "l" + ], + [ + "\\n *", + " " + ], + [ + "return", + " " + ], + [ + "de", + "x" + ], + [ + "wa", + "p" + ], + [ + "o", + "p" + ], + [ + "token", + "Id" + ], + [ + "d", + "it" + ], + [ + "byt", + "es" + ], + [ + " ", + "= " + ], + [ + "T", + "h" + ], + [ + "tu", + "al" + ], + [ + "b", + "u" + ], + [ + "c", + "h" + ], + [ + "i", + "th" + ], + [ + "r", + "tual" + ], + [ + "vi", + "rtual" + ], + [ + "sp", + "ender" + ], + [ + ".\\n *", + "/\\n function " + ], + [ + "ow", + "anc" + ], + [ + "s", + "h" + ], + [ + "contrac", + "t" + ], + [ + "int", + "ernal " + ], + [ + ",", + "\\n " + ], + [ + "a", + "ppro" + ], + [ + "F", + "ee" + ], + [ + "p", + "ri" + ], + [ + "o", + " " + ], + [ + ");", + "\\n " + ], + [ + "ext", + "ernal" + ], + [ + "A", + "d" + ], + [ + "v", + "at" + ], + [ + "\\n", + "\\n" + ], + [ + "in", + " " + ], + [ + "pri", + "vat" + ], + [ + "t", + "al" + ], + [ + "o", + "ver" + ], + [ + "7", + "2" + ], + [ + "public", + " " + ], + [ + "z", + "er" + ], + [ + "a", + "i" + ], + [ + "e", + "s " + ], + [ + "-", + "-" + ], + [ + ") {", + "\\n " + ], + [ + "a", + "nt" + ], + [ + "(", + "address " + ], + [ + "f", + "or " + ], + [ + "re", + "c" + ], + [ + "i", + "f " + ], + [ + ") ", + "internal " + ], + [ + "e", + "v" + ], + [ + "72", + "1" + ], + [ + "no", + "t " + ], + [ + ".", + " " + ], + [ + "u", + "m" + ], + [ + "a", + "tor" + ], + [ + "a", + "f" + ], + [ + "w", + "h" + ], + [ + "es", + "s" + ], + [ + "I", + "n" + ], + [ + "view", + " " + ], + [ + "in", + "dex" + ], + [ + "dat", + "a" + ], + [ + "ERC", + "721" + ], + [ + "3", + "2" + ], + [ + "er", + "f" + ], + [ + "a", + "tion" + ], + [ + "an", + "d " + ], + [ + "\\n }\\n\\n ", + "/**\\n * @dev " + ], + [ + "a", + "t " + ], + [ + "c", + "on" + ], + [ + "A", + "m" + ], + [ + "abl", + "e" + ], + [ + ".s", + "ol" + ], + [ + "ti", + "n" + ], + [ + "memor", + "y" + ], + [ + "s", + "/" + ], + [ + "i", + "t " + ], + [ + "Am", + "ount" + ], + [ + "tin", + "g" + ], + [ + "m", + "o" + ], + [ + "C", + "o" + ], + [ + "}", + " " + ], + [ + "erf", + "ac" + ], + [ + "all", + "owanc" + ], + [ + "\\", + "t" + ], + [ + "ev", + "ent" + ], + [ + "n", + "ew" + ], + [ + "en", + " " + ], + [ + "\\n ", + " " + ], + [ + "Ad", + "dres" + ], + [ + "se", + "t" + ], + [ + "a", + "y" + ], + [ + "\\n * ", + "- " + ], + [ + "g", + "et" + ], + [ + "@", + "@" + ], + [ + "u", + "r" + ], + [ + "d", + "i" + ], + [ + "to", + "tal" + ], + [ + ");", + "\\n" + ], + [ + ";", + "\\n " + ], + [ + "S", + "u" + ], + [ + " ", + "to " + ], + [ + "s ", + "the " + ], + [ + "dit", + "y" + ], + [ + "im", + "p" + ], + [ + "privat", + "e " + ], + [ + "u", + "e " + ], + [ + "i", + "ent" + ], + [ + "l", + "i" + ], + [ + "memor", + "y " + ], + [ + ")", + ", " + ], + [ + "sh", + "ip" + ], + [ + "Co", + "nt" + ], + [ + "Addres", + "s" + ], + [ + "ol", + "i" + ], + [ + "t", + "er" + ], + [ + "over", + "ri" + ], + [ + ".", + "." + ], + [ + "g", + "n" + ], + [ + "e", + "i" + ], + [ + "p", + "ro" + ], + [ + "Su", + "pp" + ], + [ + " ", + "of " + ], + [ + "\\r", + "\\n" + ], + [ + "F", + "rom" + ], + [ + "from", + " " + ], + [ + "a", + "b" + ], + [ + "virtual", + " " + ], + [ + "b", + "y " + ], + [ + "bytes", + "32" + ], + [ + "A", + "ppro" + ], + [ + "M", + "a" + ], + [ + "ad", + "d" + ], + [ + "c", + "k" + ], + [ + "Re", + "turn" + ], + [ + "v", + "e " + ], + [ + "require", + "(" + ], + [ + "tr", + "ue" + ], + [ + "\\r", + "\\n " + ], + [ + "S", + "ender" + ], + [ + "ext", + "ernal " + ], + [ + "ro", + "r" + ], + [ + "s", + ":" + ], + [ + "{", + "\\n " + ], + [ + "m", + "int" + ], + [ + "msg", + "Sender" + ], + [ + "ip", + "ient" + ], + [ + "w", + "ith" + ], + [ + ") ", + "external " + ], + [ + "a", + "s " + ], + [ + "int", + "ernal" + ], + [ + "val", + "ue " + ], + [ + "c", + "e " + ], + [ + "th", + "at " + ], + [ + "ec", + "k" + ], + [ + "A", + "ll" + ], + [ + "er", + "ator" + ], + [ + "zer", + "o " + ], + [ + "////", + "////" + ], + [ + "rec", + "ipient" + ], + [ + "address", + "(" + ], + [ + "appro", + "ve" + ], + [ + "if ", + "(" + ], + [ + "p", + "ar" + ], + [ + "int", + "erfac" + ], + [ + "**", + "**" + ], + [ + "str", + "ing" + ], + [ + "s", + "ender" + ], + [ + "af", + "e" + ], + [ + "p", + "o" + ], + [ + "on", + "ly" + ], + [ + ", ", + "uint256 " + ], + [ + "balanc", + "e" + ], + [ + "b", + "e" + ], + [ + "c", + "l" + ], + [ + "str", + "ing " + ], + [ + "F", + "or" + ], + [ + "/", + " " + ], + [ + "c", + "ur" + ], + [ + "ac", + "k" + ], + [ + "re", + "ver" + ], + [ + "_", + "msgSender" + ], + [ + "ag", + "e" + ], + [ + ") ", + "public " + ], + [ + "Supp", + "ly" + ], + [ + "if", + "i" + ], + [ + "contrac", + "t " + ], + [ + "E", + "x" + ], + [ + "00", + "00" + ], + [ + "the ", + "zero " + ], + [ + "T", + "H" + ], + [ + "su", + "b" + ], + [ + "p", + "r" + ], + [ + "ai", + "r" + ], + [ + "m", + "ent" + ], + [ + "O", + "f" + ], + [ + "k", + "e" + ], + [ + "re", + "nt" + ], + [ + "the zero ", + "address" + ], + [ + "er", + "ror" + ], + [ + "========", + "========" + ], + [ + "1", + "6" + ], + [ + "Token", + "s" + ], + [ + "z", + "e" + ], + [ + "f", + "f" + ], + [ + "re", + "d" + ], + [ + "ma", + "x" + ], + [ + "n", + "am" + ], + [ + "abl", + "e " + ], + [ + "a ", + "s" + ], + [ + "(", + "uint256 " + ], + [ + "en", + "g" + ], + [ + "token", + " " + ], + [ + "I", + "ERC20" + ], + [ + "s", + "." + ], + [ + "eng", + "th" + ], + [ + "us", + "t " + ], + [ + "ch", + "eck" + ], + [ + "l", + "ow" + ], + [ + "th", + "is" + ], + [ + "C", + "all" + ], + [ + "Th", + "e " + ], + [ + "m", + "in" + ], + [ + "d", + "e " + ], + [ + "I", + "T" + ], + [ + "S", + "e" + ], + [ + "u", + "c" + ], + [ + "msg", + ".s" + ], + [ + "msg.s", + "ender" + ], + [ + "balanc", + "es" + ], + [ + "0", + "." + ], + [ + "is", + "wap" + ], + [ + "t", + "a" + ], + [ + "as", + "h" + ], + [ + "l", + "y " + ], + [ + "th", + "e" + ], + [ + ";", + "\\n" + ], + [ + "v", + "ed" + ], + [ + "Owner", + "ship" + ], + [ + "V", + "2" + ], + [ + "o", + "t" + ], + [ + "==", + " " + ], + [ + ">", + " " + ], + [ + "Th", + "is " + ], + [ + "u", + "p" + ], + [ + "E", + "TH" + ], + [ + "m", + "ust " + ], + [ + "at", + "e" + ], + [ + "s", + "y" + ], + [ + "cur", + "rent" + ], + [ + "Appro", + "val" + ], + [ + ";", + "\\n\\n" + ], + [ + "c", + "re" + ], + [ + "n", + "um" + ], + [ + "bu", + "rn" + ], + [ + ", ", + "p" + ], + [ + "on", + " " + ], + [ + "--", + "--" + ], + [ + "B", + "alanc" + ], + [ + "c", + "e" + ], + [ + "iswap", + "V2" + ], + [ + "co", + "de" + ], + [ + "a", + "tu" + ], + [ + ");", + "\\n\\n " + ], + [ + "pp", + "el" + ], + [ + "at", + "a" + ], + [ + "it", + "s " + ], + [ + "a", + "se" + ], + [ + "t", + "ar" + ], + [ + "l", + "ength" + ], + [ + "op", + "erator" + ], + [ + "nam", + "e" + ], + [ + "view ", + "returns (" + ], + [ + "only", + "Owner" + ], + [ + "cl", + "u" + ], + [ + "qui", + "dity" + ], + [ + "with", + " " + ], + [ + "m", + "b" + ], + [ + "em", + "ent" + ], + [ + "}", + "\\n" + ], + [ + "is", + "t" + ], + [ + ");\\n", + "\\n " + ], + [ + "\\n * - ", + "`" + ], + [ + " ", + "is " + ], + [ + "mb", + "ol" + ], + [ + "a", + "re " + ], + [ + "or", + "t " + ], + [ + "dit", + "y " + ], + [ + "]", + " " + ], + [ + "sy", + "mbol" + ], + [ + " ", + "_" + ], + [ + "ai", + "l" + ], + [ + ");", + "\\n }\\n\\n /**\\n * @dev " + ], + [ + "token", + "s " + ], + [ + "h", + "a" + ], + [ + "si", + "gn" + ], + [ + ", ", + "address " + ], + [ + ";", + "\\n\\n " + ], + [ + "pr", + "ag" + ], + [ + ".", + "0" + ], + [ + "ar", + "d" + ], + [ + "e ", + "{" + ], + [ + "total", + "Supply" + ], + [ + "prag", + "m" + ], + [ + ") {\\n ", + "return " + ], + [ + "es", + "t" + ], + [ + "res", + "ul" + ], + [ + "byt", + "es " + ], + [ + "Return", + "s the " + ], + [ + "address(", + "0" + ], + [ + "M", + "int" + ], + [ + "a s", + "oli" + ], + [ + "pragm", + "a soli" + ], + [ + "c", + "an" + ], + [ + "c", + "c" + ], + [ + "th", + "is " + ], + [ + "lo", + "g" + ], + [ + "contract", + "s/" + ], + [ + "O", + "p" + ], + [ + "par", + "am" + ], + [ + "pp", + "ing" + ], + [ + "imp", + "ort " + ], + [ + "R", + "ou" + ], + [ + "o", + "ck" + ], + [ + "'", + "s " + ], + [ + "V", + "al" + ], + [ + "(", + "\\n " + ], + [ + "\\r", + "\\n " + ], + [ + "p", + "a" + ], + [ + "_", + "balances" + ], + [ + "l", + "ement" + ], + [ + ", ", + "\\\"" + ], + [ + "str", + "uc" + ], + [ + "s", + "wap" + ], + [ + "c", + "an " + ], + [ + "ifi", + "er" + ], + [ + "i", + "ll" + ], + [ + "Cont", + "rac" + ], + [ + "0", + "x" + ], + [ + ")", + "." + ], + [ + "u", + "t" + ], + [ + " *", + " " + ], + [ + "R", + "ol" + ], + [ + "not ", + "be " + ], + [ + "U", + "R" + ], + [ + "\\n ", + "// " + ], + [ + "al", + "s" + ], + [ + "h", + "t" + ], + [ + "pu", + "re" + ], + [ + "Re", + "quire" + ], + [ + "R", + "ec" + ], + [ + "L", + "i" + ], + [ + ";", + "\\n }\\n\\n /**\\n * @dev " + ], + [ + "p", + "er" + ], + [ + "f", + "o" + ], + [ + "n", + "d" + ], + [ + "e", + "es" + ], + [ + "tar", + "get" + ], + [ + "all", + "et" + ], + [ + " ", + " " + ], + [ + "i", + "ti" + ], + [ + "ab", + "i" + ], + [ + "e", + "(" + ], + [ + "wh", + "en " + ], + [ + "ERC20", + ": " + ], + [ + ".sol", + "\\\"" + ], + [ + "e", + "th" + ], + [ + "g", + "r" + ], + [ + "t", + "y" + ], + [ + "overri", + "de " + ], + [ + "ting", + " " + ], + [ + "ic", + "en" + ], + [ + "ma", + "pping" + ], + [ + "Require", + "ment" + ], + [ + "ess", + "age" + ], + [ + "ill", + " " + ], + [ + "p", + "ay" + ], + [ + "P", + "air" + ], + [ + "_", + "owner" + ], + [ + "//", + "/ " + ], + [ + "Requirement", + "s:" + ], + [ + " ", + "(" + ], + [ + "bytes32", + " " + ], + [ + "zer", + "o" + ], + [ + "i", + "d" + ], + [ + "index", + "ed" + ], + [ + "`", + "to" + ], + [ + "w", + "ill " + ], + [ + "n", + "on" + ], + [ + "interfac", + "e" + ], + [ + "bool", + " " + ], + [ + "@@", + "@@" + ], + [ + "M", + "essage" + ], + [ + "pu", + "re " + ], + [ + "Contrac", + "t" + ], + [ + "f", + "or" + ], + [ + "I", + "N" + ], + [ + "@", + "param" + ], + [ + "!", + "= " + ], + [ + "\\n", + " " + ], + [ + "W", + "ith" + ], + [ + "S", + "i" + ], + [ + "4", + "." + ], + [ + "E", + "m" + ], + [ + "B", + "u" + ], + [ + "uint", + " " + ], + [ + "cc", + "ess" + ], + [ + "em", + "it" + ], + [ + "de", + "c" + ], + [ + "ow", + "n" + ], + [ + "Balanc", + "e" + ], + [ + ") {", + "\\n " + ], + [ + "as", + "t" + ], + [ + "Rec", + "ei" + ], + [ + "st", + "ant" + ], + [ + "balance", + "Of" + ], + [ + "L", + "icen" + ], + [ + "mo", + "d" + ], + [ + "Val", + "ue" + ], + [ + "h", + " " + ], + [ + "Rou", + "ter" + ], + [ + "import ", + "\\\"" + ], + [ + "0.", + "8" + ], + [ + "ro", + "le" + ], + [ + "_", + "A" + ], + [ + "I", + "P" + ], + [ + "de", + "nt" + ], + [ + "i", + "l" + ], + [ + "F", + "F" + ], + [ + "su", + "pp" + ], + [ + "pure ", + "returns (" + ], + [ + ",\\n ", + "uint256 " + ], + [ + "op", + "en" + ], + [ + "ed ", + "to " + ], + [ + "dec", + "im" + ], + [ + "1", + "2" + ], + [ + "con", + "stant" + ], + [ + "ppel", + "in" + ], + [ + "// ", + "S" + ], + [ + "W", + "allet" + ], + [ + "am", + "p" + ], + [ + "Requirements:", + "\\n *" + ], + [ + "clu", + "d" + ], + [ + "I", + "ERC721" + ], + [ + "of ", + "the " + ], + [ + "ti", + "m" + ], + [ + "overri", + "de" + ], + [ + "error", + "Message" + ], + [ + ".\\n *\\n * ", + "Requirements:\\n *" + ], + [ + "`", + "from" + ], + [ + "di", + "v" + ], + [ + "1", + "0" + ], + [ + "index", + "ed " + ], + [ + "al", + " " + ], + [ + "cont", + "ent" + ], + [ + "un", + "iswapV2" + ], + [ + "All", + "owanc" + ], + [ + "Licen", + "se" + ], + [ + "ze", + "ppelin" + ], + [ + "an", + "d" + ], + [ + "s", + "[" + ], + [ + "\\n ", + "// " + ], + [ + "can", + "not be " + ], + [ + "S", + "wap" + ], + [ + "m", + "ul" + ], + [ + "bl", + "ock" + ], + [ + "_", + "transfer" + ], + [ + "pragma soli", + "dity " + ], + [ + "p", + "re" + ], + [ + "allowanc", + "e" + ], + [ + "atu", + "re" + ], + [ + "open", + "zeppelin" + ], + [ + "UR", + "I" + ], + [ + "token", + "s" + ], + [ + "ol", + "d" + ], + [ + "view ", + "virtual " + ], + [ + "I", + "nt" + ], + [ + "address(0", + "), " + ], + [ + "M", + "M" + ], + [ + "I", + "dent" + ], + [ + ".sol", + "\"" + ], + [ + "privat", + "e" + ], + [ + "\"", + "content" + ], + [ + "\"content", + "\"" + ], + [ + "num", + "b" + ], + [ + "\\n }\\n\\n ", + "function " + ], + [ + "/", + "contracts/" + ], + [ + "string ", + "memory " + ], + [ + "ag", + "e " + ], + [ + "M", + "IT" + ], + [ + "co", + "m" + ], + [ + "si", + "on" + ], + [ + " ", + "b" + ], + [ + "\\n *", + "\\n * " + ], + [ + "S", + "afe" + ], + [ + "r", + "a" + ], + [ + "ed ", + "by " + ], + [ + "up", + "dat" + ], + [ + " of ", + "the " + ], + [ + "P", + "D" + ], + [ + "ac", + "t" + ], + [ + "an", + "g" + ], + [ + "event", + " " + ], + [ + "X", + "-" + ], + [ + "ifier", + ": " + ], + [ + "-", + "Ident" + ], + [ + "License", + "-Ident" + ], + [ + "License-Ident", + "ifier: " + ], + [ + "PD", + "X-" + ], + [ + "PDX-", + "License-Identifier: " + ], + [ + "D", + "ata" + ], + [ + "]", + " = " + ], + [ + ") external ", + "view returns (" + ], + [ + "{", + "\\n " + ], + [ + "ac", + "tion" + ], + [ + "\\n ", + " " + ], + [ + "u", + "ti" + ], + [ + "// S", + "PDX-License-Identifier: " + ], + [ + "Ow", + "n" + ], + [ + "\\\"", + ");\\n " + ], + [ + "s", + "afe" + ], + [ + "i", + "g" + ], + [ + "16", + "5" + ], + [ + "\"", + "// SPDX-License-Identifier: " + ], + [ + "imp", + "lement" + ], + [ + "In", + "dex" + ], + [ + "U", + "p" + ], + [ + ") internal ", + "pure returns (" + ], + [ + "l", + "in" + ], + [ + "as", + "s" + ], + [ + "`", + "." + ], + [ + "`", + "amount" + ], + [ + "****", + "****" + ], + [ + "i", + "z" + ], + [ + "new", + "Owner" + ], + [ + "iti", + "al" + ], + [ + "no", + "ti" + ], + [ + "Li", + "quidity" + ], + [ + "it", + "y" + ], + [ + "(\\n ", + "address " + ], + [ + "a", + "u" + ], + [ + "st", + "ar" + ], + [ + "C", + "ount" + ], + [ + "p", + "l" + ], + [ + "To", + "tal" + ], + [ + "v", + "ail" + ], + [ + "@", + "noti" + ], + [ + "E", + "IP" + ], + [ + "ha", + "ve " + ], + [ + "uti", + "l" + ], + [ + "all", + "ow" + ], + [ + "////////", + "////////" + ], + [ + ",\\n ", + "address " + ], + [ + "ec", + "t" + ], + [ + "}\\n", + "\"" + ], + [ + "the ", + "call" + ], + [ + ";", + "\\n " + ], + [ + "al", + "se" + ], + [ + "f", + "alse" + ], + [ + "s", + "end" + ], + [ + "Ma", + "th" + ], + [ + "d", + "o" + ], + [ + ".\\n */\\n function ", + "_" + ], + [ + "clud", + "ed" + ], + [ + "ar", + "ke" + ], + [ + "bu", + "y" + ], + [ + "f", + "low" + ], + [ + "util", + "s/" + ], + [ + ";", + " " + ], + [ + "@noti", + "ce " + ], + [ + "em", + "it " + ], + [ + "tokenId", + "` " + ], + [ + "F", + "ees" + ], + [ + "Token", + "Transfer" + ], + [ + "O", + "n" + ], + [ + "decim", + "als" + ], + [ + ".", + "_" + ], + [ + "est", + "amp" + ], + [ + "h", + "ash" + ], + [ + "returns (", + "bool" + ], + [ + "ERC", + "165" + ], + [ + "\\n *", + "/\\n function " + ], + [ + "en", + "code" + ], + [ + "O", + "N" + ], + [ + "re", + "d " + ], + [ + "li", + "b" + ], + [ + "uint", + "8" + ], + [ + "@", + "openzeppelin" + ], + [ + ";", + "\\n " + ], + [ + "resul", + "t " + ], + [ + "su", + "ccess" + ], + [ + "o", + "th" + ], + [ + "un", + "check" + ], + [ + "arke", + "ting" + ], + [ + "U", + "n" + ], + [ + "function", + "Call" + ], + [ + "Si", + "gn" + ], + [ + "allowanc", + "e " + ], + [ + "rever", + "t " + ], + [ + "wh", + "ic" + ], + [ + "Se", + "e {" + ], + [ + "\"// SPDX-License-Identifier: ", + "MIT" + ], + [ + "ti", + "c" + ], + [ + "0.8", + ".0" + ], + [ + "t", + "p" + ], + [ + "in", + "ce " + ], + [ + "transfer", + "From" + ], + [ + "}", + "\\n " + ], + [ + "Rol", + "e" + ], + [ + "ht", + "tp" + ], + [ + "P", + "er" + ], + [ + "_", + "approve" + ], + [ + "to", + ", " + ], + [ + ");\\n\\n ", + "/**\\n * @dev " + ], + [ + "e ", + "the " + ], + [ + "et", + "ad" + ], + [ + "o", + "f" + ], + [ + "` ", + "cannot be " + ], + [ + "\\n", + "\\t" + ], + [ + "_msgSender", + "(" + ], + [ + "pragma solidity ", + "^" + ], + [ + "(", + "_" + ], + [ + "`", + "`" + ], + [ + "o", + "k" + ], + [ + "lo", + "ad" + ], + [ + "\\n", + "// " + ], + [ + "s:", + "//" + ], + [ + "abi", + "." + ], + [ + "/", + "\\n " + ], + [ + "\\n *", + "/" + ], + [ + "http", + "s://" + ], + [ + "+", + " " + ], + [ + "\\r", + "\\n * " + ], + [ + "Em", + "its " + ], + [ + "over", + "flow" + ], + [ + "p", + "ack" + ], + [ + "s", + "ince " + ], + [ + "ul", + "t" + ], + [ + "[", + "] " + ], + [ + "s", + ", " + ], + [ + "po", + "s" + ], + [ + "` ", + "is " + ], + [ + "_", + "is" + ], + [ + "ation", + " " + ], + [ + "\\n * ", + "@dev " + ], + [ + "struc", + "tor" + ], + [ + "rever", + "t" + ], + [ + "(", + "\\\"" + ], + [ + "de", + "ad" + ], + [ + "@openzeppelin", + "/contracts/" + ], + [ + "Ma", + "x" + ], + [ + "vail", + "able " + ], + [ + "le", + "g" + ], + [ + "O", + "ut" + ], + [ + ")", + ")" + ], + [ + "}", + "\\n\\n" + ], + [ + "ce", + "ed" + ], + [ + "T", + "im" + ], + [ + "con", + "structor" + ], + [ + "bytes ", + "memory " + ], + [ + "N", + "T" + ], + [ + "` ", + "to " + ], + [ + "` cannot be ", + "the zero address" + ], + [ + "allowanc", + "es" + ], + [ + "P", + "ro" + ], + [ + "log", + "(" + ], + [ + "S", + "tr" + ], + [ + "I", + "D" + ], + [ + "be", + "fo" + ], + [ + "r", + "ar" + ], + [ + "`", + ", " + ], + [ + "M", + "in" + ], + [ + "\\n */", + "\\n" + ], + [ + "\\n ", + "// " + ], + [ + "a", + "us" + ], + [ + "----", + "----" + ], + [ + "return", + "data" + ], + [ + "dat", + "a " + ], + [ + "is", + "tr" + ], + [ + "Ex", + "cluded" + ], + [ + " ", + "the " + ], + [ + "I", + "d " + ], + [ + "de", + "leg" + ], + [ + "S", + "et" + ], + [ + "e", + "g" + ], + [ + "a", + "k" + ], + [ + "Op", + "en" + ], + [ + "Allowanc", + "e" + ], + [ + "abl", + "ed" + ], + [ + "amount", + " " + ], + [ + "lo", + "ck" + ], + [ + "Int", + "erfac" + ], + [ + "em", + "bl" + ], + [ + "@param", + " " + ], + [ + "S", + "el" + ], + [ + "se", + "t " + ], + [ + "ass", + "embl" + ], + [ + "r", + "ou" + ], + [ + "1", + "8" + ], + [ + "v", + "4." + ], + [ + "can ", + "be " + ], + [ + "star", + "t" + ], + [ + "se", + "ll" + ], + [ + "\"", + "ERC20: " + ], + [ + "0", + ", " + ], + [ + ") internal ", + "virtual " + ], + [ + "th", + "an " + ], + [ + "A", + "T" + ], + [ + "I", + "f " + ], + [ + "s ", + "to " + ], + [ + "abi.", + "encode" + ], + [ + "ty", + "p" + ], + [ + "_", + "allowances" + ], + [ + "C", + "h" + ], + [ + "#", + "#" + ], + [ + "..", + "/" + ], + [ + "lin", + "e" + ], + [ + "or", + "t" + ], + [ + "Return", + "s " + ], + [ + "..", + ".." + ], + [ + "re", + "mo" + ], + [ + "de", + "f" + ], + [ + "ans", + "action" + ], + [ + " ", + "!= " + ], + [ + "c", + "ol" + ], + [ + ";\\n\\n", + "/**" + ], + [ + ">", + "= " + ], + [ + "on", + "ly " + ], + [ + "ta", + "x" + ], + [ + "at", + "e " + ], + [ + "ro", + "l" + ], + [ + "A", + "S" + ], + [ + "} ", + "event" + ], + [ + ".", + "\\n * " + ], + [ + "S", + "oli" + ], + [ + " ", + "for " + ], + [ + ".\\n *\\n * Requirements:\\n *", + "\\n * - `" + ], + [ + "ex", + "ist" + ], + [ + "as", + "t " + ], + [ + "lib", + "rar" + ], + [ + "Safe", + "Math" + ], + [ + "a", + "x" + ], + [ + "Sign", + "ature" + ], + [ + "ou", + "t " + ], + [ + "H", + "ash" + ], + [ + "balanc", + "e " + ], + [ + "new", + " " + ], + [ + ".", + "\\n * - `" + ], + [ + ":", + "= " + ], + [ + "\\n\\n", + "pragma solidity ^" + ], + [ + ".\\n *\\n * ", + "Emits " + ], + [ + "di", + "tion" + ], + [ + "pa", + "th" + ], + [ + ".\\n *", + "/\\n " + ], + [ + "rec", + "ei" + ], + [ + ") ", + "private " + ], + [ + ") public ", + "view virtual " + ], + [ + "ma", + "in" + ], + [ + "po", + "int" + ], + [ + "`amount", + "` " + ], + [ + "Own", + "able" + ], + [ + "0", + " " + ], + [ + "ac", + "tor" + ], + [ + "in ", + "the " + ], + [ + "O", + "R" + ], + [ + ".sol\\\"", + ";\\n" + ], + [ + "qu", + "ant" + ], + [ + "0000", + "0000" + ], + [ + "ed", + "(" + ], + [ + "Cont", + "ext" + ], + [ + "L", + "E" + ], + [ + "Recei", + "ver" + ], + [ + "Str", + "ing" + ], + [ + "a", + "p" + ], + [ + "a ", + "{" + ], + [ + "pay", + "able" + ], + [ + "T", + "ax" + ], + [ + "li", + "quidity" + ], + [ + "dead", + "line" + ], + [ + "transfer", + " " + ], + [ + "whic", + "h " + ], + [ + "= ", + "_" + ], + [ + "f", + "ee" + ], + [ + "it", + "s" + ], + [ + "6", + "4" + ], + [ + "uniswapV2", + "Router" + ], + [ + "R", + "E" + ], + [ + "]", + "." + ], + [ + "\\", + "\\" + ], + [ + "y", + "al" + ], + [ + "e", + "ip" + ], + [ + "s", + "c" + ], + [ + "l", + "at" + ], + [ + "\\r", + "\\n " + ], + [ + ". ", + "This " + ], + [ + "================", + "================" + ], + [ + " ", + "<" + ], + [ + "\\r", + "\\n function " + ], + [ + "P", + "ay" + ], + [ + "f", + "i" + ], + [ + "E", + "n" + ], + [ + "ent", + "r" + ], + [ + "co", + "ver" + ], + [ + "etad", + "ata" + ], + [ + "block", + "." + ], + [ + "s", + "tor" + ], + [ + "Token", + "Id" + ], + [ + " ", + "== " + ], + [ + "For", + "All" + ], + [ + "_is", + "Excluded" + ], + [ + "Bu", + "rn" + ], + [ + "ou", + "l" + ], + [ + "vailable ", + "since " + ], + [ + "_A", + "vailable since " + ], + [ + "(", + "abi.encode" + ], + [ + "ed", + "Value" + ], + [ + "is ", + "not " + ], + [ + "interfac", + "e " + ], + [ + "`", + "tokenId` " + ], + [ + "\\r", + "\\n *" + ], + [ + "us", + "ing " + ], + [ + "P", + "ool" + ], + [ + "L", + "o" + ], + [ + "N", + "ot" + ], + [ + "from", + ", " + ], + [ + "re", + "g" + ], + [ + "befo", + "re" + ], + [ + ", uint256 ", + "amount" + ], + [ + "+", + "= " + ], + [ + "e", + "t " + ], + [ + "ou", + "r" + ], + [ + "s", + "e " + ], + [ + "t", + "w" + ], + [ + ")", + "\\n " + ], + [ + "\\n }", + "\\n" + ], + [ + "E", + "D" + ], + [ + "se", + "l" + ], + [ + "int", + "256" + ], + [ + "a", + "in" + ], + [ + "re", + "as" + ], + [ + "itial", + "iz" + ], + [ + "a", + "ult" + ], + [ + "owner", + "ship" + ], + [ + "=", + "> " + ], + [ + "override ", + "returns (" + ], + [ + "}", + ".\\n */\\n function " + ], + [ + ".sol\\\";\\n", + "import \\\"" + ], + [ + "the", + "re" + ], + [ + "em", + "p" + ], + [ + "_", + "_" + ], + [ + ";\\n\\n/**", + "\\n * @dev " + ], + [ + "o", + "min" + ], + [ + "2", + "4" + ], + [ + "_", + "S" + ], + [ + "i", + "v" + ], + [ + "p", + "air" + ], + [ + "string ", + "memory" + ], + [ + "lo", + "t" + ], + [ + "er ", + "of " + ], + [ + "t", + "ed " + ], + [ + "the zero address", + "\"" + ], + [ + "must ", + "be " + ], + [ + "*", + " " + ], + [ + "w", + "ard" + ], + [ + "appro", + "ved" + ], + [ + "resul", + "t" + ], + [ + "█", + "█" + ], + [ + "\\n\\t", + "\\t" + ], + [ + "_", + "symbol" + ], + [ + "d", + "en" + ], + [ + "{\\n ", + "require(" + ], + [ + "token", + "/" + ], + [ + "uncheck", + "ed " + ], + [ + "_", + "mint" + ], + [ + "before", + "TokenTransfer" + ], + [ + "D", + "el" + ], + [ + ",", + "\\n " + ], + [ + "Un", + "iswapV2" + ], + [ + "i", + "d " + ], + [ + "cre", + "ase" + ], + [ + "Sel", + "l" + ], + [ + "{", + "\\n " + ], + [ + "an", + "y " + ], + [ + "at", + "ed" + ], + [ + ") {", + "\\n " + ], + [ + "Up", + "dat" + ], + [ + "le", + "a" + ], + [ + "Z", + "e" + ], + [ + "Appro", + "ved" + ], + [ + "\\n\\npragma solidity ^", + "0.8.0" + ], + [ + "es", + "s " + ], + [ + "tim", + "estamp" + ], + [ + "ff", + "ff" + ], + [ + ") public ", + "virtual " + ], + [ + "will ", + "be " + ], + [ + "Open", + "Ze" + ], + [ + "ic", + "e" + ], + [ + ");", + "\\n " + ], + [ + "omin", + "ator" + ], + [ + "\\\"", + ");\\n\\n " + ], + [ + "O", + "T" + ], + [ + "@@@@", + "@@@@" + ], + [ + "ch", + "ang" + ], + [ + "numb", + "er" + ], + [ + "pro", + "d" + ], + [ + ", ", + "amount" + ], + [ + "to", + "m" + ], + [ + "e ", + "= " + ], + [ + "c", + "ent" + ], + [ + "d", + "er" + ], + [ + "supp", + "ort" + ], + [ + "quant", + "ity" + ], + [ + ");\\n ", + "return " + ], + [ + "sub", + "tr" + ], + [ + "n", + "ext" + ], + [ + "_", + "totalSupply" + ], + [ + "IERC20", + "-" + ], + [ + "call", + " " + ], + [ + "t", + "e" + ], + [ + ")", + "\\\"" + ], + [ + "op", + "er" + ], + [ + "P", + "aus" + ], + [ + "b", + "ase" + ], + [ + "With", + "Signature" + ], + [ + "ab", + "str" + ], + [ + ".", + "/" + ], + [ + "there", + "um" + ], + [ + "h", + "old" + ], + [ + "p", + "res" + ], + [ + "` cannot be the zero address", + ".\\n * - `" + ], + [ + "R", + "O" + ], + [ + "Bu", + "y" + ], + [ + "ppel", + "in " + ], + [ + "\\n }\\n", + "}\\n\"" + ], + [ + "us", + "er" + ], + [ + "oul", + "d " + ], + [ + "v", + "ed " + ], + [ + "s", + "t " + ], + [ + "Count", + "er" + ], + [ + "p", + "1" + ], + [ + "\\r", + "\\n }" + ], + [ + "K", + "K" + ], + [ + "vi", + "ou" + ], + [ + ",\\n address ", + "to" + ], + [ + "` ", + "and " + ], + [ + "OpenZe", + "ppelin " + ], + [ + "3", + "3" + ], + [ + "FF", + "FF" + ], + [ + ", ", + "and " + ], + [ + "current", + " " + ], + [ + "1", + "00" + ], + [ + "add", + "(" + ], + [ + " ", + " " + ], + [ + "░", + "░" + ], + [ + "us", + "ed " + ], + [ + "ra", + "w" + ], + [ + "r", + "c" + ], + [ + "safe", + "Transfer" + ], + [ + "\\n ", + "/// " + ], + [ + "\"", + "@openzeppelin/contracts/" + ], + [ + "bu", + "t " + ], + [ + "address(", + "this" + ], + [ + "Address", + ": " + ], + [ + "9", + "6" + ], + [ + "A", + "R" + ], + [ + "_", + "max" + ], + [ + "gr", + "ad" + ], + [ + " ", + "{\\n " + ], + [ + "I", + "UniswapV2" + ], + [ + "ma", + "y " + ], + [ + "_balances", + "[" + ], + [ + "m", + "p" + ], + [ + ") internal ", + "view " + ], + [ + "en", + "sion" + ], + [ + ");\\n", + "\\t" + ], + [ + "pre", + "viou" + ], + [ + "Fee", + "On" + ], + [ + "OpenZeppelin ", + "Contract" + ], + [ + "_", + "name" + ], + [ + "d", + "is" + ], + [ + "(", + "from, " + ], + [ + "s", + "to" + ], + [ + "ec", + "c" + ], + [ + "ecc", + "ak" + ], + [ + "k", + "eccak" + ], + [ + "_", + "value" + ], + [ + ":", + ":" + ], + [ + "Op", + "erator" + ], + [ + "}", + "." + ], + [ + "Recei", + "ved" + ], + [ + "den", + "ominator" + ], + [ + "p", + "2" + ], + [ + "\\r\\n }", + "\\r\\n" + ], + [ + "_", + "to" + ], + [ + "_isExcluded", + "From" + ], + [ + ";\\n\\n", + "import \\\"" + ], + [ + "}\\n\\n", + "\\t" + ], + [ + ") ", + "external" + ], + [ + ");", + "\\n }\\n\\n function " + ], + [ + "o", + "ok" + ], + [ + "v", + "o" + ], + [ + "address(0), ", + "\\\"" + ], + [ + "keccak", + "256" + ], + [ + ".sol", + ")" + ], + [ + "B", + "B" + ], + [ + "ex", + "ceed" + ], + [ + "gr", + "ant" + ], + [ + "non", + "-" + ], + [ + "\\n ", + " * " + ], + [ + "C", + "on" + ], + [ + "m", + "arketing" + ], + [ + "M", + "etadata" + ], + [ + "re", + "ad" + ], + [ + "W", + "h" + ], + [ + "\"// SPDX-License-Identifier: MIT", + "\\n// " + ], + [ + "\\", + "u" + ], + [ + "\\u", + "00" + ], + [ + "_", + "beforeTokenTransfer" + ], + [ + " ", + "> " + ], + [ + "a", + "ti" + ], + [ + "{", + "\\n\\t\\t" + ], + [ + "En", + "abled" + ], + [ + "&", + "&" + ], + [ + "uint256", + ") {\\n " + ], + [ + "ro", + "w" + ], + [ + "MM", + "MM" + ], + [ + "Lo", + "g" + ], + [ + "interface", + "Id" + ], + [ + "R", + "ew" + ], + [ + "error", + " " + ], + [ + "(", + ") external view returns (" + ], + [ + "or", + "m" + ], + [ + "of ", + "`" + ], + [ + "uint ", + "amount" + ], + [ + "}\\n\\n\\t", + "function " + ], + [ + "a", + "im" + ], + [ + "call", + "data" + ], + [ + "WithSignature", + "(\\\"" + ], + [ + ")", + ");\\n\\t" + ], + [ + "(abi.encode", + "WithSignature(\\\"" + ], + [ + "actor", + "y" + ], + [ + "all", + " " + ], + [ + "g", + "en" + ], + [ + "re", + "f" + ], + [ + ") internal view ", + "{\\n\\t\\t" + ], + [ + "(abi.encodeWithSignature(\\\"", + "log(" + ], + [ + "remo", + "ve" + ], + [ + ", p", + "0" + ], + [ + ")\\\"", + ", p0" + ], + [ + "ex", + "p" + ], + [ + "Rew", + "ard" + ], + [ + "_", + "t" + ], + [ + "u", + "se" + ], + [ + "clu", + "de" + ], + [ + ".", + "\\n " + ], + [ + "pack", + "ed" + ], + [ + "I", + "ERC165" + ], + [ + "ar", + "k" + ], + [ + "_", + "token" + ], + [ + "v", + "el" + ], + [ + "]", + "[" + ], + [ + "as", + "e " + ], + [ + "}", + "\\n " + ], + [ + "h", + "as " + ], + [ + "all", + "y " + ], + [ + "l", + "e " + ], + [ + "uniswapV2", + "Pair" + ], + [ + "Re", + "entr" + ], + [ + "R", + "es" + ], + [ + "us", + "e " + ], + [ + ";", + "\\n }\\n\\n " + ], + [ + "B", + "IT" + ], + [ + "the ", + "owner" + ], + [ + "T", + "x" + ], + [ + "a {", + "Transfer" + ], + [ + "ar", + "i" + ], + [ + ", ", + "_" + ], + [ + "im", + "it" + ], + [ + "m", + "an" + ], + [ + "ou", + "n" + ], + [ + "Z", + "Z" + ], + [ + ".", + "or" + ], + [ + "e", + "thereum" + ], + [ + "A", + "L" + ], + [ + "`to", + "` " + ], + [ + "A", + "t" + ], + [ + "si", + "bl" + ], + [ + "af", + "ter" + ], + [ + "in", + "d" + ], + [ + "Transfer", + "red" + ], + [ + "stor", + "age " + ], + [ + "ec", + "h" + ], + [ + " ", + "- " + ], + [ + "ERC721", + "A" + ], + [ + "su", + "per" + ], + [ + "num", + "er" + ], + [ + "m", + "e" + ], + [ + "be", + "en " + ], + [ + "12", + "8" + ], + [ + "constant", + " " + ], + [ + "uint256", + ") {\\n return " + ], + [ + "numb", + "er of " + ], + [ + "E", + "numer" + ], + [ + "er ", + "than " + ], + [ + "Soli", + "dity" + ], + [ + "e ", + "that " + ], + [ + ";", + "\\r\\n" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// ", + "OpenZeppelin Contract" + ], + [ + "3", + "." + ], + [ + "_", + "burn" + ], + [ + ");", + "\\n " + ], + [ + "Approval", + "ForAll" + ], + [ + "(address ", + "owner" + ], + [ + " ", + "and " + ], + [ + "(", + "tokenId" + ], + [ + "ro", + "p" + ], + [ + ") public view virtual ", + "override returns (" + ], + [ + ".\\n *\\n * Requirements:\\n *", + "\\n * - " + ], + [ + "E", + "r" + ], + [ + "`", + "account" + ], + [ + "ac", + "t " + ], + [ + ");", + "\\r\\n" + ], + [ + "Ownership", + "Transferred" + ], + [ + "mo", + "re " + ], + [ + ");", + "\\n }\\n\\n " + ], + [ + ";", + "\\n }\\n\\n function " + ], + [ + "Er", + "ror" + ], + [ + ",\\n address to", + ",\\n uint256 " + ], + [ + "al", + "e" + ], + [ + "Tokens", + "For" + ], + [ + "support", + "s" + ], + [ + "account", + " " + ], + [ + "a", + "ting " + ], + [ + "onlyOwner", + " " + ], + [ + "call", + "data " + ], + [ + "Ad", + "min" + ], + [ + "zero", + ", " + ], + [ + "supports", + "Interfac" + ], + [ + "Pay", + "load" + ], + [ + "m", + "it" + ], + [ + "`.", + "\\n * - " + ], + [ + "block.", + "timestamp" + ], + [ + "s ", + "a " + ], + [ + "l", + "ast" + ], + [ + "S", + "t" + ], + [ + "an ", + "{" + ], + [ + "s", + "rc" + ], + [ + "********", + "********" + ], + [ + "tion", + " " + ], + [ + "R", + "o" + ], + [ + ".\\n *\\n * ", + "_Available since " + ], + [ + "sign", + "ed " + ], + [ + "updat", + "ed " + ], + [ + "), ", + "\\\"" + ], + [ + ".", + "length" + ], + [ + "assembl", + "y " + ], + [ + "M", + "o" + ], + [ + "E", + "NT" + ], + [ + "M", + "arketing" + ], + [ + "M", + "A" + ], + [ + "(address ", + "=> " + ], + [ + "N", + "um" + ], + [ + "p", + "ool" + ], + [ + "_", + "send" + ], + [ + "v", + "ent" + ], + [ + "|", + " " + ], + [ + "pres", + "ent" + ], + [ + "(\\n address ", + "from" + ], + [ + "sc", + "ri" + ], + [ + "[] ", + "memory " + ], + [ + "s ", + "are " + ], + [ + ".\\n *\\n * Emits ", + "a {Transfer" + ], + [ + ".sol)", + "\\n\\npragma solidity ^0.8.0" + ], + [ + "@param", + " _" + ], + [ + "safeTransfer", + "From" + ], + [ + "ext", + "ension" + ], + [ + "} ", + "el" + ], + [ + ", p", + "1" + ], + [ + ")\\\", p0", + ", p1" + ], + [ + "(address ", + "indexed " + ], + [ + "Tr", + "ansaction" + ], + [ + "I", + "M" + ], + [ + "ark", + "et" + ], + [ + "rou", + "nd" + ], + [ + "must ", + "have " + ], + [ + "k", + "e " + ], + [ + "a", + "pp" + ], + [ + "owner", + ", " + ], + [ + "Log", + "Payload" + ], + [ + "_send", + "LogPayload" + ], + [ + "er", + "ve" + ], + [ + "pragma soli", + "dity" + ], + [ + "am", + "e " + ], + [ + "ed ", + "in " + ], + [ + "tw", + "o " + ], + [ + "m", + "ech" + ], + [ + "M", + "IN" + ], + [ + "s", + "-" + ], + [ + "\\n * ", + "`" + ], + [ + "I", + "ON" + ], + [ + "S", + "ta" + ], + [ + ") ", + "= " + ], + [ + ";\\n }\\n\\n /**\\n * @dev ", + "See {" + ], + [ + "ec", + "tor" + ], + [ + "subtr", + "act" + ], + [ + "if ", + "the " + ], + [ + "sh", + "ould " + ], + [ + ", address ", + "indexed " + ], + [ + "(\\n address from", + ",\\n address to,\\n uint256 " + ], + [ + "updat", + "e" + ], + [ + "uint", + "16" + ], + [ + "su", + "m" + ], + [ + "mech", + "an" + ], + [ + "es", + "t " + ], + [ + "y", + "p" + ], + [ + "the call", + "er" + ], + [ + "mechan", + "is" + ], + [ + "j", + "ect" + ], + [ + ";\\n\\n ", + "// " + ], + [ + ");", + "\\r\\n " + ], + [ + "E", + "_" + ], + [ + "l", + "ast " + ], + [ + "w", + "e " + ], + [ + "address", + "," + ], + [ + "pu", + "t" + ], + [ + "re", + "ward" + ], + [ + "pro", + "of" + ], + [ + "/**\\n * ", + "@notice " + ], + [ + "re", + "main" + ], + [ + "le", + "vel" + ], + [ + "p", + "3" + ], + [ + "'", + "t " + ], + [ + "sign", + "atu" + ], + [ + "_", + "amount" + ], + [ + "2", + "7" + ], + [ + "is", + "i" + ], + [ + "bytes", + "4" + ], + [ + ", ", + "string memory " + ], + [ + "(from, ", + "to, " + ], + [ + ", p", + "2" + ], + [ + ")\\\", p0, p1", + ", p2" + ], + [ + "f", + "ees" + ], + [ + "n", + "e" + ], + [ + "f", + "fer" + ], + [ + "(address ", + "account" + ], + [ + "ou", + "t" + ], + [ + "R", + "ate" + ], + [ + ") internal ", + "view virtual " + ], + [ + "+", + "+" + ], + [ + ",", + "\\r\\n " + ], + [ + "yal", + "ty" + ], + [ + "1", + " " + ], + [ + "amount ", + "exceed" + ], + [ + "grad", + "e" + ], + [ + "v", + "3." + ], + [ + "tr", + "a" + ], + [ + "ERC721", + "Received" + ], + [ + "._", + "\\n */\\n function " + ], + [ + "d", + "raw" + ], + [ + "de", + "p" + ], + [ + "(uint256 ", + "tokenId" + ], + [ + "/", + "EIP" + ], + [ + "Ch", + "eck" + ], + [ + "\\\\", + "x" + ], + [ + ")", + ".\\n *\\n * " + ], + [ + "vi", + "d" + ], + [ + "po", + "si" + ], + [ + "S", + "S" + ], + [ + "P", + "r" + ], + [ + "allow", + "ed" + ], + [ + "subtract", + "edValue" + ], + [ + "re", + "n" + ], + [ + "A", + "u" + ], + [ + "_A", + "D" + ], + [ + "I", + "mp" + ], + [ + "ver", + "if" + ], + [ + "Ex", + "act" + ], + [ + "the", + "\\n * " + ], + [ + "on", + "e " + ], + [ + "st", + "a" + ], + [ + "lat", + "er" + ], + [ + "bu", + "ffer" + ], + [ + "es", + "[" + ], + [ + "In", + "itializ" + ], + [ + "unchecked ", + "{\\n " + ], + [ + ".or", + "g" + ], + [ + "es", + "/" + ], + [ + "spender", + "` " + ], + [ + "sign", + "ature" + ], + [ + "Tim", + "estamp" + ], + [ + "Re", + "cover" + ], + [ + "P", + "o" + ], + [ + "t ", + "to " + ], + [ + "Rol", + "e(" + ], + [ + "us", + "ed" + ], + [ + "call", + "ed " + ], + [ + "ch", + " " + ], + [ + "``", + "'s " + ], + [ + "d", + "own" + ], + [ + ">", + "> " + ], + [ + "fi", + "r" + ], + [ + "appro", + "ve " + ], + [ + "add", + "r" + ], + [ + ".", + "\\n *\\n * " + ], + [ + " ", + "`" + ], + [ + "(", + "address(0), " + ], + [ + "crease", + "Allowance" + ], + [ + "er ", + "is not " + ], + [ + "ing ", + "the " + ], + [ + "f", + "ail" + ], + [ + "amount", + " of " + ], + [ + " ", + " " + ], + [ + "mul", + "ti" + ], + [ + "x", + "ref" + ], + [ + "us", + "ing" + ], + [ + "implement", + "ation" + ], + [ + "ff", + "ic" + ], + [ + ";\\n }\\n\\n /**\\n * @dev ", + "Returns the " + ], + [ + "after", + "TokenTransfer" + ], + [ + "m", + "ut" + ], + [ + ",", + "," + ], + [ + "_", + "in" + ], + [ + "Imp", + "lement" + ], + [ + "b", + "ack" + ], + [ + ";", + "\\n " + ], + [ + "ad", + "ing" + ], + [ + "O", + "O" + ], + [ + "k", + "er" + ], + [ + "s", + "oli" + ], + [ + "`", + ".\\n */\\n function " + ], + [ + "o", + "c" + ], + [ + "returns (bool", + ") {\\n " + ], + [ + "E", + "th" + ], + [ + "at ", + "le" + ], + [ + " != ", + "address(0), \\\"" + ], + [ + "; ", + "// " + ], + [ + "e", + "ad" + ], + [ + "f", + "e" + ], + [ + "W", + "ETH" + ], + [ + "ic", + "ation" + ], + [ + "Del", + "eg" + ], + [ + "an {", + "Approval" + ], + [ + ".", + "\\n " + ], + [ + "0", + ") {\\n " + ], + [ + "iv", + "en " + ], + [ + "no", + "t" + ], + [ + ",", + "\\n * " + ], + [ + "ow", + " " + ], + [ + "bytes ", + "memory" + ], + [ + "eth", + "er " + ], + [ + ") internal view {\\n\\t\\t", + "_sendLogPayload" + ], + [ + ") internal view {\\n\\t\\t_sendLogPayload", + "(abi.encodeWithSignature(\\\"log(" + ], + [ + "M", + "arket" + ], + [ + "de", + "l" + ], + [ + " ", + " " + ], + [ + ", ", + "bool " + ], + [ + "));\\n\\t", + "}\\n\\n\\tfunction " + ], + [ + "s ", + "`amount` " + ], + [ + "for ", + "the " + ], + [ + "when ", + "the " + ], + [ + "pos", + "sibl" + ], + [ + "Se", + "t " + ], + [ + "it", + "y " + ], + [ + "target", + ", " + ], + [ + ") internal ", + "view returns (" + ], + [ + "--------", + "--------" + ], + [ + "uint256 ", + "private " + ], + [ + "base", + "URI" + ], + [ + "amount exceed", + "s " + ], + [ + "3", + "0" + ], + [ + "}\\n", + "\\n " + ], + [ + "assembl", + "y" + ], + [ + "<", + "= " + ], + [ + "appro", + "val" + ], + [ + "ERC20", + "/" + ], + [ + "_", + "tax" + ], + [ + "burn", + "ed" + ], + [ + "E", + "X" + ], + [ + "`", + ".\\n *\\n * " + ], + [ + "g", + "ht" + ], + [ + "5", + "5" + ], + [ + "v", + "ari" + ], + [ + "tr", + "y" + ], + [ + "ifi", + "er " + ], + [ + "token/", + "ERC20/" + ], + [ + "E", + "C" + ], + [ + "ffic", + "ient" + ], + [ + ".", + "\\n " + ], + [ + "val", + "id " + ], + [ + "P", + "ack" + ], + [ + "\\n *", + "\\n * " + ], + [ + "`", + "owner" + ], + [ + "\\n ", + " " + ], + [ + "at", + "a " + ], + [ + "rec", + "t" + ], + [ + "tokens", + "For" + ], + [ + "bytes memory ", + "data" + ], + [ + "tic", + " " + ], + [ + "mod", + "ifier" + ], + [ + "ed", + "i" + ], + [ + "g", + "iven " + ], + [ + "previou", + "s" + ], + [ + ";\\n", + "\\n " + ], + [ + "(uint256 ", + "a" + ], + [ + "_", + "decimals" + ], + [ + "g", + "as " + ], + [ + "} event", + ".\\n */\\n function " + ], + [ + "mapping", + "(address => " + ], + [ + "B", + "yt" + ], + [ + "e", + "." + ], + [ + "act ", + "contract " + ], + [ + "<", + " " + ], + [ + "res", + "erve" + ], + [ + "b", + "er" + ], + [ + ";\\n\\n ", + "/**\\n * @dev " + ], + [ + ".\\n *\\n * _Available since ", + "v3." + ], + [ + "D", + "ev" + ], + [ + "D", + "e" + ], + [ + "l", + "ist" + ], + [ + "(", + "1" + ], + [ + "A", + "NT" + ], + [ + "SafeMath", + ": " + ], + [ + "sp", + "ec" + ], + [ + "start", + "TokenId" + ], + [ + "_", + "T" + ], + [ + "abstr", + "act contract " + ], + [ + "(", + ")" + ], + [ + "With", + "Value" + ], + [ + "functionCall", + "WithValue" + ], + [ + "librar", + "y " + ], + [ + "; ", + "i" + ], + [ + "========", + "====" + ], + [ + "il", + "e " + ], + [ + "gen", + "er" + ], + [ + "tr", + "ansaction" + ], + [ + ";\\n ", + "}\\n " + ], + [ + ");\\n\\n /**\\n * @dev ", + "Returns the " + ], + [ + "(", + "bool " + ], + [ + "is", + "Contract" + ], + [ + "uncheck", + "ed" + ], + [ + "f", + "in" + ], + [ + "acc", + "ess" + ], + [ + "D", + "RE" + ], + [ + "U", + "s" + ], + [ + "g", + "et " + ], + [ + "ex", + "t " + ], + [ + "}", + "\\n }\\n\\n /**\\n * @dev " + ], + [ + "es", + "e " + ], + [ + "le", + "ction" + ], + [ + "ind", + "ic" + ], + [ + "recei", + "ver" + ], + [ + "F", + "or " + ], + [ + "ar", + "d " + ], + [ + "S", + "/" + ], + [ + "owner", + " " + ], + [ + ".", + "\\n */\\n" + ], + [ + "To", + " " + ], + [ + "1", + "9" + ], + [ + "ER", + "_" + ], + [ + "lo", + "y" + ], + [ + "A", + "nd" + ], + [ + "signatu", + "re " + ], + [ + "reg", + "istr" + ], + [ + "pp", + "ing " + ], + [ + "eip", + "-" + ], + [ + "hold", + "er" + ], + [ + "/EIP", + "S/" + ], + [ + "/EIPS/", + "eip-" + ], + [ + "s", + "e {" + ], + [ + "////////////////", + "////////////////" + ], + [ + "string", + "," + ], + [ + ");\\n ", + "_" + ], + [ + "ethereum", + ".org" + ], + [ + "s.", + "ethereum.org" + ], + [ + "https://", + "eip" + ], + [ + "s.ethereum.org", + "/EIPS/eip-" + ], + [ + "https://eip", + "s.ethereum.org/EIPS/eip-" + ], + [ + "msg", + "." + ], + [ + ", uint256 ", + "b" + ], + [ + "`", + "]" + ], + [ + "supp", + "ly" + ], + [ + "N", + "OT" + ], + [ + "token", + "Amount" + ], + [ + "m", + "is" + ], + [ + "p", + "t" + ], + [ + "bool", + "," + ], + [ + "el", + "se" + ], + [ + "================", + "============" + ], + [ + "\\r\\n", + " " + ], + [ + "int", + "eg" + ], + [ + ", p", + "3" + ], + [ + ")\\\", p0, p1, p2", + ", p3" + ], + [ + "A", + "c" + ], + [ + "DRE", + "SS" + ], + [ + "_t", + "Total" + ], + [ + "struc", + "t " + ], + [ + "Enumer", + "able" + ], + [ + "erf", + "orm" + ], + [ + "(uint256 a", + ", uint256 b" + ], + [ + "(", + "owner, " + ], + [ + "t", + "emp" + ], + [ + "\\n ", + " " + ], + [ + ") {\\n ", + "require(" + ], + [ + "set", + "ApprovalForAll" + ], + [ + "2", + "6" + ], + [ + "that ", + "is " + ], + [ + "amount", + "ETH" + ], + [ + "wa", + "s " + ], + [ + "s ", + "for " + ], + [ + "================================", + "============================" + ], + [ + "total", + " " + ], + [ + "to", + "re" + ], + [ + "re", + "at" + ], + [ + "c", + "or" + ], + [ + "c", + "ount" + ], + [ + "All", + "ow" + ], + [ + "typ", + "e(" + ], + [ + "dep", + "loy" + ], + [ + "Tx", + "Amount" + ], + [ + "sub", + "(" + ], + [ + "oth", + " " + ], + [ + "IERC721", + "Receiver" + ], + [ + "} el", + "se {" + ], + [ + "pro", + "ject" + ], + [ + "....", + "...." + ], + [ + "Em", + "it" + ], + [ + "\\r\\n ", + "/**" + ], + [ + "u", + "es" + ], + [ + "in", + "ver" + ], + [ + "val", + "id" + ], + [ + "Q", + "u" + ], + [ + "level", + " " + ], + [ + "function", + "s " + ], + [ + "st", + "and" + ], + [ + "deleg", + "at" + ], + [ + "============================================================", + "=" + ], + [ + "di", + "g" + ], + [ + ");\\n }\\n\\n /**\\n * @dev ", + "S" + ], + [ + "ar", + "g" + ], + [ + "P", + "O" + ], + [ + "si", + "ze" + ], + [ + " ", + " " + ], + [ + "Tim", + "e" + ], + [ + "f", + "l" + ], + [ + "r", + "ay" + ], + [ + "\\\");\\n ", + "require(" + ], + [ + ")", + "\\n " + ], + [ + ";", + "\\r\\n " + ], + [ + "A", + "ccess" + ], + [ + "Emit", + "ted " + ], + [ + ".", + "com" + ], + [ + "with", + "out " + ], + [ + "&&", + " " + ], + [ + "s", + "ol" + ], + [ + "amount", + "Token" + ], + [ + "m", + "ar" + ], + [ + "\\n ", + " *" + ], + [ + "im", + "mut" + ], + [ + "p", + "0" + ], + [ + "our", + " " + ], + [ + "[", + "`" + ], + [ + "co", + "de " + ], + [ + ") internal virtual ", + "{\\n " + ], + [ + "to", + ", uint256 " + ], + [ + "Solidity", + "'s " + ], + [ + "th", + "en " + ], + [ + ") ", + "/ " + ], + [ + "00", + "0" + ], + [ + "indic", + "ating " + ], + [ + "ver", + "sion" + ], + [ + "success", + ", " + ], + [ + "S", + "A" + ], + [ + "of ", + "a " + ], + [ + "S", + "T" + ], + [ + "ti", + "ve" + ], + [ + "ad", + "min" + ], + [ + "`", + ". " + ], + [ + "Cont", + "rol" + ], + [ + "pack", + "ed " + ], + [ + "a", + "re" + ], + [ + "Router", + "0" + ], + [ + "transfer", + " to " + ], + [ + "t", + "er " + ], + [ + ");", + "\\n function " + ], + [ + "S", + "lot" + ], + [ + "clude", + "From" + ], + [ + ")", + "\\n " + ], + [ + "{", + "approve" + ], + [ + "rever", + "ting " + ], + [ + "m", + "eth" + ], + [ + "0.8", + "." + ], + [ + "tr", + "ue " + ], + [ + ".sol\\\"", + ";\\n\\n/**\\n * @dev " + ], + [ + "ou", + " " + ], + [ + "ic", + " " + ], + [ + "/// ", + "@notice " + ], + [ + " ", + "+ " + ], + [ + "_", + "from" + ], + [ + "mod", + "ul" + ], + [ + "er", + "k" + ], + [ + "im", + "um" + ], + [ + "W", + "e " + ], + [ + "es ", + "not " + ], + [ + "tokens ", + "from " + ], + [ + "re", + "present" + ], + [ + "no", + " " + ], + [ + ".", + "\\r\\n *" + ], + [ + "ac", + "h" + ], + [ + "1", + "1" + ], + [ + "(", + ") " + ], + [ + "pa", + "used" + ], + [ + "on", + "ERC721Received" + ], + [ + " ", + ":= " + ], + [ + "_AD", + "DRESS" + ], + [ + "address(0", + ")" + ], + [ + "s", + "lot" + ], + [ + "ERC721", + ": " + ], + [ + "meth", + "o" + ], + [ + "div", + "isi" + ], + [ + "emit ", + "Transfer" + ], + [ + ") public virtual ", + "override " + ], + [ + "sel", + "ector" + ], + [ + "Ad", + "d" + ], + [ + "Ma", + "ker" + ], + [ + " ", + "from " + ], + [ + "N", + "on" + ], + [ + "s", + "\\n * " + ], + [ + "_", + "r" + ], + [ + "s ", + "= " + ], + [ + "_", + "set" + ], + [ + "p", + "0, " + ], + [ + "@", + "return " + ], + [ + "Market", + "Maker" + ], + [ + "MarketMaker", + "Pair" + ], + [ + "ated", + "MarketMakerPair" + ], + [ + "tom", + "atedMarketMakerPair" + ], + [ + "IUniswapV2", + "Router0" + ], + [ + "if (", + "value " + ], + [ + "I", + "t " + ], + [ + "i", + "o" + ], + [ + "Soli", + "dity " + ], + [ + "verif", + "y" + ], + [ + " b", + "its" + ], + [ + "to", + "col" + ], + [ + "wh", + "ether " + ], + [ + "librar", + "y" + ], + [ + "or", + "ting" + ], + [ + "su", + "fficient" + ], + [ + "swap", + "Exact" + ], + [ + "\\n ", + "//" + ], + [ + "I", + "C" + ], + [ + "Z", + "er" + ], + [ + "\\n ", + "// " + ], + [ + "at", + "ed " + ], + [ + "ex", + "ec" + ], + [ + "_", + "afterTokenTransfer" + ], + [ + "re", + "cover" + ], + [ + "`", + "value" + ], + [ + "call", + " to " + ], + [ + "_transfer", + "Ownership" + ], + [ + "at", + "ch" + ], + [ + "au", + "th" + ], + [ + "In", + "fo" + ], + [ + "D", + "rop" + ], + [ + "mint", + "ed " + ], + [ + "##", + "##" + ], + [ + "def", + "ault" + ], + [ + "i", + "bu" + ], + [ + "FeeOn", + "Transfer" + ], + [ + "\\r\\n /**", + "\\r\\n * " + ], + [ + "E", + "N" + ], + [ + "Supp", + "orting" + ], + [ + "Supporting", + "FeeOnTransfer" + ], + [ + "SupportingFeeOnTransfer", + "Tokens" + ], + [ + "o", + "m" + ], + [ + "own", + "ed by " + ], + [ + "Access", + "Control" + ], + [ + "w", + "or" + ], + [ + "lo", + "t " + ], + [ + ".com", + "/" + ], + [ + "3", + "9" + ], + [ + "R", + "A" + ], + [ + "ing", + "\\n * " + ], + [ + ") internal view virtual ", + "returns (" + ], + [ + "l", + "ess " + ], + [ + "(", + "value" + ], + [ + "appro", + "ved " + ], + [ + "ch", + "ain" + ], + [ + "Pr", + "ice" + ], + [ + "extension", + "s/" + ], + [ + "supportsInterfac", + "e(" + ], + [ + "ab", + "out " + ], + [ + "name", + "_" + ], + [ + "constant", + " _" + ], + [ + "s", + "\"" + ], + [ + "revert ", + "reas" + ], + [ + "def", + "in" + ], + [ + "ad", + "dition" + ], + [ + "T", + "yp" + ], + [ + "interface", + "Id " + ], + [ + "f", + "it " + ], + [ + "e", + "ction" + ], + [ + "il", + "te" + ], + [ + "_msgSender(", + ")" + ], + [ + "th", + "em" + ], + [ + " > ", + "0" + ], + [ + ", ", + "uint " + ], + [ + "m", + "in " + ], + [ + "d", + "er " + ], + [ + "amount", + "s" + ], + [ + "B", + "ase" + ], + [ + "un", + "signed " + ], + [ + "amount", + "Out" + ], + [ + "v", + "ok" + ], + [ + "?", + " " + ], + [ + " = ", + "_" + ], + [ + "in", + "cre" + ], + [ + ") {", + "\\r\\n " + ], + [ + "PO", + "S" + ], + [ + "Solidity's ", + "`" + ], + [ + "symbol", + "_" + ], + [ + "/", + "\\r\\n function " + ], + [ + "Ownable", + ": " + ], + [ + "typ", + "e" + ], + [ + "Total", + "Fees" + ], + [ + "ame ", + "as " + ], + [ + "s", + "(" + ], + [ + "with", + "draw" + ], + [ + "RO", + "LE" + ], + [ + "g", + "u" + ], + [ + "current", + "Allowanc" + ], + [ + ");\\n", + "}\\n\"" + ], + [ + "f", + "ul" + ], + [ + "uint256 ", + "public " + ], + [ + "the", + "y " + ], + [ + "cl", + "aim" + ], + [ + " <", + " " + ], + [ + "` and ", + "`to` " + ], + [ + "` and `to` ", + "are " + ], + [ + "ffff", + "ffff" + ], + [ + "v", + "es" + ], + [ + "on", + "d" + ], + [ + "Ch", + "ang" + ], + [ + ") ", + "revert " + ], + [ + ") internal pure returns (", + "uint256) {\\n " + ], + [ + " {\\n ", + "/**\\n * @dev " + ], + [ + "packed", + "Ownership" + ], + [ + "Reentr", + "ant" + ], + [ + "al", + "read" + ], + [ + "transfer", + "red " + ], + [ + "low", + "-" + ], + [ + "mechanis", + "m" + ], + [ + "int", + "o " + ], + [ + "e", + "re " + ], + [ + "tr", + "ading" + ], + [ + "8", + "8" + ], + [ + "_", + "address" + ], + [ + "s ", + "v4." + ], + [ + "g", + "ner" + ], + [ + "u", + "b" + ], + [ + "m", + "ess" + ], + [ + "del", + "et" + ], + [ + "al", + "c" + ], + [ + "add", + "edValue" + ], + [ + "_", + "get" + ], + [ + "` is ", + "zero, " + ], + [ + "implement", + " " + ], + [ + "ar", + " " + ], + [ + "p", + "erform" + ], + [ + "th", + "ese " + ], + [ + "e", + "ith" + ], + [ + "y", + ", " + ], + [ + "the ", + "current " + ], + [ + " ", + " " + ], + [ + "U", + "int" + ], + [ + ".\\n */\\n ", + "event " + ], + [ + "m", + "load" + ], + [ + "non", + "Reentrant" + ], + [ + "de", + "cre" + ], + [ + "uint", + "64" + ], + [ + "ver", + "t" + ], + [ + "../", + "../" + ], + [ + "9", + "8" + ], + [ + "token ", + "ID" + ], + [ + "current", + "Index" + ], + [ + "IM", + "P" + ], + [ + "]", + ";\\n " + ], + [ + "token", + "B" + ], + [ + "Per", + "cent" + ], + [ + "address", + "-" + ], + [ + "ame as ", + "{" + ], + [ + "current", + "Allowance" + ], + [ + "unsigned ", + "integ" + ], + [ + "owner", + "Of" + ], + [ + "fir", + "st " + ], + [ + "ent", + " to " + ], + [ + "pu", + "t " + ], + [ + "(", + "msg.sender" + ], + [ + "-", + "address-" + ], + [ + "ERC", + "2" + ], + [ + "} ", + "or " + ], + [ + "con", + "dition" + ], + [ + "\"", + "SafeMath: " + ], + [ + "-", + "}" + ], + [ + "_isExcludedFrom", + "Fee" + ], + [ + "xref", + "-" + ], + [ + "ame as {", + "xref-" + ], + [ + "-}", + "[`" + ], + [ + ", ", + "s" + ], + [ + "Up", + "grade" + ], + [ + "_", + "buy" + ], + [ + "o", + "s" + ], + [ + "alread", + "y " + ], + [ + "P", + "ar" + ], + [ + "mod", + "ifier " + ], + [ + "eith", + "er " + ], + [ + "n", + "ap" + ], + [ + "account", + " (" + ], + [ + "at le", + "ast " + ], + [ + "B", + "e" + ], + [ + "on", + "g" + ], + [ + "n", + "'t " + ], + [ + "_msgSender(", + "), " + ], + [ + "tra", + "Data" + ], + [ + "soli", + "dity" + ], + [ + "ing ", + "a " + ], + [ + "Deleg", + "ate" + ], + [ + "fail", + "ed" + ], + [ + "Liquidity", + "Fee" + ], + [ + "(address ", + "spender" + ], + [ + "} ", + "event " + ], + [ + "f", + "ig" + ], + [ + "wa", + "y " + ], + [ + "b", + "ot" + ], + [ + "` ", + "operator" + ], + [ + "par", + "t to " + ], + [ + "AS", + "K" + ], + [ + "Counter", + "part to " + ], + [ + "g", + "h " + ], + [ + "1", + " (" + ], + [ + "nap", + "sh" + ], + [ + "for", + "ma" + ], + [ + "istr", + "ibu" + ], + [ + ");\\n }\\n\\n /**\\n * @dev S", + "ame as {xref-" + ], + [ + "H", + "ook" + ], + [ + "ec", + "aus" + ], + [ + "Implement", + "ation" + ], + [ + "O", + "r" + ], + [ + "f", + "actory" + ], + [ + "M", + "ASK" + ], + [ + "- ", + "`" + ], + [ + "oper", + "ation " + ], + [ + ";", + "\\r\\n }\\r\\n" + ], + [ + ";\\n }\\n\\n /**\\n * @dev See {", + "IERC20-" + ], + [ + "b", + "y" + ], + [ + "er", + "s" + ], + [ + "Re", + "g" + ], + [ + "Per", + "mit" + ], + [ + "MA", + "X" + ], + [ + "\\r\\n /**\\r\\n * ", + "@dev " + ], + [ + "ERC20", + " " + ], + [ + "Balanc", + "e " + ], + [ + "P", + "ER" + ], + [ + "es ", + "the " + ], + [ + "Own", + "ed" + ], + [ + ".\\n *\\n * ", + "This " + ], + [ + "er", + "y" + ], + [ + "B", + "lock" + ], + [ + "it", + "el" + ], + [ + "`to", + "`.\\n * - " + ], + [ + ") ", + "(" + ], + [ + "en", + "abled" + ], + [ + "pl", + "ac" + ], + [ + "e", + ". " + ], + [ + ", \\\"", + "Address: " + ], + [ + "\\n ", + ") external " + ], + [ + "qui", + "val" + ], + [ + "EC", + "D" + ], + [ + "mess", + "age " + ], + [ + "F", + "T" + ], + [ + "(", + ") external " + ], + [ + "int", + "er" + ], + [ + "Zer", + "o" + ], + [ + "ECD", + "SA" + ], + [ + ", ", + "it " + ], + [ + "is", + "Approved" + ], + [ + "Address", + "-" + ], + [ + "\"ERC20: ", + "transfer " + ], + [ + " != address(0), \\\"", + "ERC20: " + ], + [ + "D", + "E" + ], + [ + ";\\n ", + "emit " + ], + [ + "pr", + "ice" + ], + [ + "IUniswapV2Router0", + "2" + ], + [ + "L", + "ast" + ], + [ + "ex", + "cludeFrom" + ], + [ + "g", + "reat" + ], + [ + "\\r", + "\\n " + ], + [ + "(", + "account" + ], + [ + "last ", + "updated " + ], + [ + "s (", + "last updated " + ], + [ + "s (last updated ", + "v4." + ], + [ + "-address-", + "bytes" + ], + [ + "(\\n address from,\\n address to,\\n uint256 ", + "tokenId" + ], + [ + "wh", + "ile " + ], + [ + "token", + "Id " + ], + [ + "g", + "as" + ], + [ + "\\n\\n ", + "/**\\n * @dev " + ], + [ + "p3", + ") internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(" + ], + [ + "no", + "red" + ], + [ + "oth", + "er " + ], + [ + "(uint256 ", + "value" + ], + [ + "(", + "(" + ], + [ + "wh", + "en" + ], + [ + ".0", + ") (" + ], + [ + "later", + "al" + ], + [ + "h", + "ook" + ], + [ + ")\\\", p0, p1, p2, p3", + "));\\n\\t}\\n\\n\\tfunction " + ], + [ + "Supp", + "ly " + ], + [ + "_", + "check" + ], + [ + "`", + "role" + ], + [ + "x", + "y" + ], + [ + ");\\n }\\n\\n /**\\n * @dev ", + "Returns the " + ], + [ + "Returns ", + "true " + ], + [ + "(", + ");\\n " + ], + [ + "ac", + "h " + ], + [ + "utils/", + "Context" + ], + [ + "(from, to, ", + "tokenId" + ], + [ + "int256", + " " + ], + [ + "ar", + "ray" + ], + [ + "result ", + "+= " + ], + [ + "amount", + "In" + ], + [ + "only ", + "be " + ], + [ + "bytes4", + " " + ], + [ + "uint8", + " " + ], + [ + "from ", + "the " + ], + [ + "per", + "cent" + ], + [ + "whic", + "h" + ], + [ + "Ro", + "yalty" + ], + [ + "Si", + "ze" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Same as {xref-", + "Address-" + ], + [ + "as", + "set" + ], + [ + "af", + "e " + ], + [ + "o", + "b" + ], + [ + "pre", + "vent" + ], + [ + "Counterpart to ", + "Solidity's `" + ], + [ + "Max", + "Transaction" + ], + [ + "onlyOwner ", + "{\\n " + ], + [ + "this ", + "function " + ], + [ + "2", + "^" + ], + [ + "t", + "ern" + ], + [ + " ", + "in " + ], + [ + "struc", + "t" + ], + [ + "C", + "l" + ], + [ + "e ", + "of the " + ], + [ + "In", + "valid" + ], + [ + "ren", + "oun" + ], + [ + "5", + "0" + ], + [ + "as ", + "a " + ], + [ + "als", + "o " + ], + [ + "F", + "e" + ], + [ + "sub", + "scri" + ], + [ + "T", + "_" + ], + [ + "oth", + "er" + ], + [ + "msg.", + "data" + ], + [ + "er", + "i" + ], + [ + "3", + "6" + ], + [ + "\\u00", + "3" + ], + [ + "etad", + "ata " + ], + [ + "r", + " " + ], + [ + "assembly ", + "{" + ], + [ + "great", + "er than " + ], + [ + ";\\n ", + "}\\n " + ], + [ + "low-", + "level " + ], + [ + "set", + "._" + ], + [ + "do", + "c" + ], + [ + "{", + "\\r\\n " + ], + [ + "F", + "actory" + ], + [ + "quival", + "ent to " + ], + [ + "as", + "k" + ], + [ + "_", + "spender" + ], + [ + "ke", + "y" + ], + [ + "FFFF", + "FFFF" + ], + [ + "AS", + "H" + ], + [ + "ol", + "low" + ], + [ + "address ", + "owner" + ], + [ + "T", + "e" + ], + [ + "d", + "st" + ], + [ + "KK", + "KK" + ], + [ + "f", + "ollow" + ], + [ + "|", + "| " + ], + [ + "C", + "ol" + ], + [ + "7", + "12" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contract", + "s (last updated v4." + ], + [ + "s ", + "that " + ], + [ + "require", + "d " + ], + [ + ");\\n\\n ", + "// " + ], + [ + "L", + "ength" + ], + [ + "(", + "a" + ], + [ + "g", + "e" + ], + [ + "r", + "it" + ], + [ + "`from", + "` to " + ], + [ + "00000000", + "00000000" + ], + [ + "A", + "U" + ], + [ + "(", + ") public view virtual override returns (" + ], + [ + "i", + "r" + ], + [ + "add", + "Liquidity" + ], + [ + "c", + "es" + ], + [ + "Byt", + "es" + ], + [ + "Te", + "am" + ], + [ + "safe", + "Mint" + ], + [ + "_", + "red" + ], + [ + "S", + "ha" + ], + [ + "cre", + "ate" + ], + [ + "with ", + "the " + ], + [ + ".sol)\\n\\npragma solidity ^0.8.0", + ";\\n\\nimport \\\"" + ], + [ + "uint", + "32" + ], + [ + "to ", + "be " + ], + [ + "oper", + "ation" + ], + [ + "BIT", + "MASK" + ], + [ + "2", + "**" + ], + [ + "_", + "total" + ], + [ + "par", + "ator" + ], + [ + "g", + "ith" + ], + [ + "s[", + "tokenId" + ], + [ + "Wh", + "en " + ], + [ + "gith", + "ub" + ], + [ + "do", + "es not " + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contract", + "s v4." + ], + [ + "C", + "ast" + ], + [ + "_", + "N" + ], + [ + "Updat", + "ed" + ], + [ + "BIT", + "POS" + ], + [ + "ZZ", + "ZZ" + ], + [ + "L", + "ock" + ], + [ + ") internal ", + "returns (" + ], + [ + "result ", + "= " + ], + [ + "su", + "ch " + ], + [ + "is", + "t " + ], + [ + "t", + "y " + ], + [ + "[] ", + "calldata " + ], + [ + "swapExact", + "TokensFor" + ], + [ + "in", + "put " + ], + [ + "(", + "bytes32 " + ], + [ + "L", + "imit" + ], + [ + "token", + "A" + ], + [ + "Rou", + "nd" + ], + [ + "4.", + "1 (" + ], + [ + "call", + "er is not " + ], + [ + "number of ", + "tokens " + ], + [ + "a", + "ul" + ], + [ + "[", + "owner" + ], + [ + "`", + "spender` " + ], + [ + ");\\n return ", + "true" + ], + [ + "o", + "t " + ], + [ + "Mint", + "er" + ], + [ + "OR", + "T" + ], + [ + "Emitted ", + "when " + ], + [ + "a", + "s the " + ], + [ + ");", + "\\n }\\n}\\n\"" + ], + [ + "} or ", + "{" + ], + [ + ",", + "\\n " + ], + [ + "e ", + "is " + ], + [ + "ou", + "nd" + ], + [ + "H", + "ASH" + ], + [ + "in", + "clud" + ], + [ + "si", + "gner" + ], + [ + "in", + "st" + ], + [ + "end", + "ing" + ], + [ + "multi", + "pl" + ], + [ + "(address owner", + ", address " + ], + [ + ") internal virtual ", + "{\\n require(" + ], + [ + "@@@@@@@@", + "@@@@@@@@" + ], + [ + "e", + "code" + ], + [ + "Addres", + "s " + ], + [ + "pay", + "able " + ], + [ + "Token", + " " + ], + [ + "if (", + "!" + ], + [ + ",", + "\\n " + ], + [ + "in", + "sufficient" + ], + [ + "W", + "ei" + ], + [ + ");\\n\\n ", + "function " + ], + [ + "P", + "L" + ], + [ + "h", + "as" + ], + [ + "{", + "IERC20-" + ], + [ + "░░", + "░░" + ], + [ + "\\u00", + "27" + ], + [ + "contract", + "s." + ], + [ + "(", + "0x" + ], + [ + ", ", + "bytes32 " + ], + [ + "4", + "0" + ], + [ + "verify", + "Call" + ], + [ + "5", + "6" + ], + [ + "to ", + "the " + ], + [ + "two ", + "unsigned integ" + ], + [ + "rn", + " " + ], + [ + "}", + "\\r\\n" + ], + [ + "uint", + "," + ], + [ + "string memory", + ") {\\n return " + ], + [ + "in", + "itial" + ], + [ + "do", + "es" + ], + [ + ".\\n *\\n * Emits ", + "an {Approval" + ], + [ + "ownership", + " " + ], + [ + "r", + "t" + ], + [ + "th", + "ei" + ], + [ + "ms", + "tore" + ], + [ + "in", + "forma" + ], + [ + "_balances[", + "account" + ], + [ + "Res", + "ult" + ], + [ + "A", + "D" + ], + [ + "Check", + "point" + ], + [ + "BB", + "BB" + ], + [ + "e.", + "g" + ], + [ + " = ", + "0" + ], + [ + "metho", + "d " + ], + [ + "renoun", + "ce" + ], + [ + "re", + "qu" + ], + [ + "val", + "ues" + ], + [ + "AT", + "OR" + ], + [ + "napsh", + "ot" + ], + [ + "ad", + "min " + ], + [ + "ERC721", + "/" + ], + [ + "Recover", + "Error" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.", + "4.1 (" + ], + [ + "_", + "data" + ], + [ + "_", + "C" + ], + [ + "c", + "ast" + ], + [ + "ma", + "k" + ], + [ + "exec", + "u" + ], + [ + "in", + "valid " + ], + [ + "`from", + "``'s " + ], + [ + "can be ", + "used " + ], + [ + "github", + ".com/" + ], + [ + "w", + "rit" + ], + [ + "_isExcludedFrom", + "Fees" + ], + [ + "co", + "d" + ], + [ + "/// ", + "@dev " + ], + [ + "IMP", + "ORT" + ], + [ + "IMPORT", + "ANT" + ], + [ + "remain", + "ing " + ], + [ + "a", + "Drop" + ], + [ + ") internal returns (", + "bytes memory" + ], + [ + "aul", + "t " + ], + [ + "⠀", + "⠀" + ], + [ + ". ", + "O" + ], + [ + "} ", + "and " + ], + [ + "tax", + "Amount" + ], + [ + "from ", + "the zero address\"" + ], + [ + ".\\n *\\n * Emits a {Transfer", + "} event.\\n */\\n function " + ], + [ + "ot", + "es" + ], + [ + "exist", + "s" + ], + [ + "verifyCall", + "Result" + ], + [ + "di", + "rect" + ], + [ + "the call", + "er " + ], + [ + "G", + "u" + ], + [ + "amount exceeds ", + "balance" + ], + [ + ") external ", + "returns (bool" + ], + [ + "call", + "ed by " + ], + [ + "_max", + "TxAmount" + ], + [ + "constructor", + "(" + ], + [ + "Mint", + "ed" + ], + [ + "vari", + "ant" + ], + [ + "erk", + "le" + ], + [ + "revert reas", + "on " + ], + [ + "as", + "ed " + ], + [ + ",\\n ", + "string memory " + ], + [ + "ig", + "h" + ], + [ + "\"", + "ev" + ], + [ + "\"ev", + "m" + ], + [ + "transfer", + "Ownership" + ], + [ + "functionCall", + "`]" + ], + [ + "functionCall", + "-address-bytes" + ], + [ + "-}[`", + "functionCall`]" + ], + [ + "L", + "ist" + ], + [ + "(", + "target, " + ], + [ + "which", + " is " + ], + [ + "alc", + "ul" + ], + [ + "isApproved", + "ForAll" + ], + [ + "Cl", + "aim" + ], + [ + "\"", + "contracts/" + ], + [ + "https://", + "github.com/" + ], + [ + "l", + "p" + ], + [ + "e", + "ach " + ], + [ + "i", + "zer" + ], + [ + ") {\\n return ", + "_" + ], + [ + "registr", + "ant" + ], + [ + "(", + "_msgSender(), " + ], + [ + "IERC721", + "-" + ], + [ + "m", + "iti" + ], + [ + ", \\\"", + "ERC20: " + ], + [ + "abstr", + "act" + ], + [ + "token/", + "ERC721/" + ], + [ + "Token", + "Balance" + ], + [ + ";\\n ", + "uint256 " + ], + [ + "_", + "D" + ], + [ + "swap", + "TokensFor" + ], + [ + "have ", + "been " + ], + [ + ") external view returns (", + "uint256" + ], + [ + "au", + "to" + ], + [ + "dis", + "able" + ], + [ + "ro", + "yal" + ], + [ + "deleg", + "ate " + ], + [ + "A", + "C" + ], + [ + "}\\n\\n", + " " + ], + [ + "Qu", + "ery" + ], + [ + "lib", + "/" + ], + [ + "down", + "cast" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-", + "functionCall-address-bytes" + ], + [ + "vi", + "a " + ], + [ + "sta", + "ke" + ], + [ + "Li", + "qui" + ], + [ + "e", + "ver" + ], + [ + "MMMM", + "MMMM" + ], + [ + "us", + "er " + ], + [ + "bool", + "e" + ], + [ + "/// ", + "@" + ], + [ + "Reentr", + "anc" + ], + [ + "$", + "$" + ], + [ + ", ", + "the " + ], + [ + "in", + "itializ" + ], + [ + "less ", + "than " + ], + [ + "Reg", + "istr" + ], + [ + "A", + " " + ], + [ + "Not", + "e that " + ], + [ + "E", + ": " + ], + [ + "uint", + "96" + ], + [ + "P", + "u" + ], + [ + "ec", + "t " + ], + [ + "0.", + "6" + ], + [ + "ecaus", + "e " + ], + [ + "itel", + "ist" + ], + [ + "vi", + "de" + ], + [ + "thei", + "r " + ], + [ + "`from` to ", + "`to" + ], + [ + ".", + "\"" + ], + [ + "l", + "ication" + ], + [ + "\\\");\\n ", + "return " + ], + [ + "4", + "c" + ], + [ + "R", + "em" + ], + [ + "supp", + "ly " + ], + [ + "balance ", + "of " + ], + [ + "y", + "ou " + ], + [ + "33", + "33" + ], + [ + "7", + "7" + ], + [ + ");", + "\\r\\n }\\r\\n" + ], + [ + "d", + "ur" + ], + [ + "in", + "Swap" + ], + [ + "l", + "imit" + ], + [ + "le", + "t " + ], + [ + "inver", + "se " + ], + [ + "amount of ", + "tokens " + ], + [ + "|", + "|" + ], + [ + "return ", + "(" + ], + [ + "l", + "arg" + ], + [ + "up", + " " + ], + [ + "NOT", + "E: " + ], + [ + "b", + "it " + ], + [ + "Transfer", + "Amount" + ], + [ + "\\n /// ", + "@param " + ], + [ + "██", + "██" + ], + [ + "a", + "vailable " + ], + [ + "on ", + "the " + ], + [ + "Tokens", + "At" + ], + [ + "ta", + "ke" + ], + [ + "1", + "12" + ], + [ + "su", + "c" + ], + [ + "by ", + "the " + ], + [ + "spender", + ", " + ], + [ + "E", + "E" + ], + [ + "m", + "all" + ], + [ + "ed ", + "= " + ], + [ + "N", + "FT" + ], + [ + "pos", + "it" + ], + [ + "divisi", + "on " + ], + [ + "max", + "imum" + ], + [ + "_", + "tokenId" + ], + [ + "C", + "an" + ], + [ + "s.", + "\\n *\\n * " + ], + [ + "M", + "ul" + ], + [ + ")\\n ", + "{\\n " + ], + [ + "suc", + "ceed" + ], + [ + ") internal ", + "{\\n " + ], + [ + "1", + "0000" + ], + [ + "Re", + "p" + ], + [ + "Operator", + "F" + ], + [ + "transferred ", + "to " + ], + [ + "_", + "currentIndex" + ], + [ + "\\n *", + " " + ], + [ + ", ", + "0x" + ], + [ + "li", + "ke " + ], + [ + " to ", + "be " + ], + [ + "max", + "Wallet" + ], + [ + "immut", + "able " + ], + [ + " ", + "overflow" + ], + [ + "\\n * ", + "@param " + ], + [ + "miti", + "g" + ], + [ + "emp", + "t" + ], + [ + ">", + ">= " + ], + [ + "i", + "red" + ], + [ + "all", + "back" + ], + [ + "stor", + "age" + ], + [ + "F", + "un" + ], + [ + "w", + "e" + ], + [ + "▓", + "▓" + ], + [ + "possibl", + "e " + ], + [ + "e.g", + ". " + ], + [ + "TokensAt", + "Amount" + ], + [ + ";", + "\\n }\\n}\\n\"" + ], + [ + ",\\n ", + "bytes32 " + ], + [ + "`", + "operator" + ], + [ + ", ", + "which " + ], + [ + "befo", + "re " + ], + [ + "`value", + "` " + ], + [ + "`", + "target" + ], + [ + "currentAllowanc", + "e " + ], + [ + "Pu", + "blic" + ], + [ + "i", + "x" + ], + [ + "the zero address", + "\\\");\\n\\n " + ], + [ + "zero", + "\"" + ], + [ + "an ", + "address " + ], + [ + "1", + ";\\n " + ], + [ + "access", + "/" + ], + [ + "inst", + "ead" + ], + [ + "er", + "s, " + ], + [ + "i", + "ze" + ], + [ + "q", + "rt" + ], + [ + "Marketing", + "Fee" + ], + [ + "M", + "an" + ], + [ + "O", + "ver" + ], + [ + "or", + "der" + ], + [ + "Allow", + "ed" + ], + [ + "on", + "\\n * " + ], + [ + "interfac", + "es/" + ], + [ + "string ", + "private " + ], + [ + "int", + "ro" + ], + [ + "Returns ", + "a " + ], + [ + "spec", + "if" + ], + [ + "amount", + "\\n " + ], + [ + "a ", + "contract" + ], + [ + "swap", + "Enabled" + ], + [ + "i", + "]" + ], + [ + "\\n // ", + "- `" + ], + [ + "Pack", + "ed" + ], + [ + "3", + "5" + ], + [ + "s ", + "of " + ], + [ + "transfer", + "red" + ], + [ + "C", + "I" + ], + [ + "cont", + "ain" + ], + [ + "the", + "re " + ], + [ + "revert", + "(" + ], + [ + "\"ERC20: ", + "approve " + ], + [ + "token", + "URI" + ], + [ + "can", + "not " + ], + [ + "][", + "spender" + ], + [ + "sp", + "ection" + ], + [ + "tokenId` ", + "must " + ], + [ + "vo", + "ke" + ], + [ + "st", + "ak" + ], + [ + ".sol\\\";\\nimport \\\"", + "./" + ], + [ + "`tokenId` ", + "token" + ], + [ + "H", + "ex" + ], + [ + "uint256", + "[] memory " + ], + [ + "boole", + "an " + ], + [ + "_", + " " + ], + [ + "a", + "in " + ], + [ + "intro", + "spection" + ], + [ + ");\\n ", + "require(" + ], + [ + "introspection", + "/" + ], + [ + "A", + "P" + ], + [ + "y", + "our " + ], + [ + "to", + "Hex" + ], + [ + "toHex", + "String" + ], + [ + "op", + "tion" + ], + [ + "app", + "lication" + ], + [ + "== ", + "0" + ], + [ + "String", + "s" + ], + [ + "s `amount` ", + "tokens from " + ], + [ + "for ", + "(uint256 " + ], + [ + "ve", + "s " + ], + [ + "re", + "e " + ], + [ + "sp", + "end" + ], + [ + "t", + "Amount" + ], + [ + "}", + ", " + ], + [ + "C", + "ha" + ], + [ + "s", + "wa" + ], + [ + "IERC20", + "Metadata" + ], + [ + "af", + "ter " + ], + [ + "AT", + "ION" + ], + [ + "ati", + "ve " + ], + [ + "M", + "B" + ], + [ + " ", + " " + ], + [ + "\"", + "*" + ], + [ + "c", + "r" + ], + [ + "contract", + "TokenBalance" + ], + [ + "ecode", + "\"" + ], + [ + "\"evm", + "." + ], + [ + "\"*", + "\"" + ], + [ + "\"", + "Address: " + ], + [ + "}", + ".\\n *\\n * " + ], + [ + "tar", + "t" + ], + [ + "A", + "r" + ], + [ + ";\\n", + " " + ], + [ + "h", + "al" + ], + [ + ", ", + "but " + ], + [ + "pro", + "tocol" + ], + [ + "f", + "t" + ], + [ + "utils/", + "introspection/" + ], + [ + ") {\\n ", + "value " + ], + [ + "Buy", + "Tax" + ], + [ + "D", + "o" + ], + [ + "p", + " " + ], + [ + "╬", + "╬" + ], + [ + ";\\n ", + "result += " + ], + [ + ";\\n }\\n ", + "if (value " + ], + [ + "\\n ", + "returns (" + ], + [ + "reas", + "ur" + ], + [ + "ERC721", + " " + ], + [ + "be", + "ing " + ], + [ + "IN", + "G" + ], + [ + "h", + "ex" + ], + [ + "ti", + "t" + ], + [ + "bytes4 ", + "interfaceId" + ], + [ + "(target, ", + "data" + ], + [ + "balance of ", + "at least " + ], + [ + "ETH", + "SupportingFeeOnTransferTokens" + ], + [ + "project", + "Id" + ], + [ + "tim", + "e" + ], + [ + "Pro", + "of" + ], + [ + "tic", + "call" + ], + [ + "er", + "c" + ], + [ + "w", + "ei" + ], + [ + "does", + "n't " + ], + [ + "w", + "allet" + ], + [ + "from ", + "`from` to `to" + ], + [ + "pre", + "v" + ], + [ + "unchecked ", + "{" + ], + [ + ".sol\\\"", + ";\\n\\n" + ], + [ + "previous", + "Owner" + ], + [ + "res", + "tr" + ], + [ + "address owner", + " = " + ], + [ + "col", + "lection" + ], + [ + "Sell", + "Tax" + ], + [ + "L", + "T" + ], + [ + "ed", + ", " + ], + [ + "C", + "re" + ], + [ + "%", + "%" + ], + [ + "recei", + "ve" + ], + [ + "grant", + "ed " + ], + [ + "(bool ", + "success, " + ], + [ + "amountOut", + "Min" + ], + [ + "acc", + "ess " + ], + [ + "mint", + " " + ], + [ + "IERC721", + "Metadata" + ], + [ + "b", + "oth " + ], + [ + "el", + "y " + ], + [ + ") public ", + "view returns (" + ], + [ + "ig", + "in" + ], + [ + "com", + "p" + ], + [ + "uint256", + "(" + ], + [ + "Token", + "s " + ], + [ + "\\n * ", + "@" + ], + [ + "mar", + "t " + ], + [ + "de", + "creaseAllowance" + ], + [ + "e", + "quivalent to " + ], + [ + "s ", + "`" + ], + [ + ".sol)\\n\\npragma solidity ^0.8.0", + ";\\n\\n/**\\n * @dev " + ], + [ + ")", + "\\n " + ], + [ + "y", + "Gu" + ], + [ + "m", + "etadata" + ], + [ + "allowance ", + "for " + ], + [ + "exp", + "ect" + ], + [ + "il", + "ter" + ], + [ + "o", + "v" + ], + [ + "whether ", + "the " + ], + [ + "di", + "vid" + ], + [ + "1", + "7" + ], + [ + "C", + "ON" + ], + [ + "re", + "voke" + ], + [ + "in", + "creaseAllowance" + ], + [ + "non", + "ce" + ], + [ + "supportsInterface(", + "bytes4 interfaceId" + ], + [ + "to", + "` cannot be the zero address.\\n * - `" + ], + [ + "us", + "tom" + ], + [ + "exist", + "ent" + ], + [ + "is", + "Fee" + ], + [ + "sel", + "f" + ], + [ + "ne", + "ver" + ], + [ + "lin", + "e " + ], + [ + ")\\n ", + "external" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - ", + "The " + ], + [ + "for (uint256 ", + "i" + ], + [ + ";", + "\\r\\n " + ], + [ + "insufficient", + " " + ], + [ + " ", + "token" + ], + [ + "interfaceId ", + "== " + ], + [ + "is ", + "the " + ], + [ + "_Available since ", + "v4." + ], + [ + "2", + "2" + ], + [ + "co", + "p" + ], + [ + "au", + "tomatedMarketMakerPair" + ], + [ + "Reentranc", + "yGu" + ], + [ + "pu", + "r" + ], + [ + "anc", + "e" + ], + [ + "bot", + "s" + ], + [ + "b", + "ecause " + ], + [ + "th", + "rou" + ], + [ + "A", + "s" + ], + [ + ",\\n ", + "bytes memory data" + ], + [ + "(uint256 a, uint256 b", + ") internal pure returns (" + ], + [ + "return ", + "true" + ], + [ + "op", + "code " + ], + [ + "O", + "U" + ], + [ + "int", + "-" + ], + [ + ", ", + "recipient" + ], + [ + "Ac", + "tive" + ], + [ + " ", + "/ " + ], + [ + "function ", + "is " + ], + [ + "lea", + "rn " + ], + [ + "(", + "address(this" + ], + [ + "more ", + "about " + ], + [ + "learn ", + "more about " + ], + [ + "h", + "int-" + ], + [ + "p", + "tion" + ], + [ + "ve ", + "the " + ], + [ + "sol", + "hint-" + ], + [ + "W", + "AR" + ], + [ + "uint", + "128" + ], + [ + "Set ", + "storage " + ], + [ + "ner", + ", " + ], + [ + "set", + "ting" + ], + [ + "fi", + "x" + ], + [ + "all", + "et " + ], + [ + "le", + "af" + ], + [ + "[", + "0" + ], + [ + " ", + "or " + ], + [ + "[", + "EIP" + ], + [ + "n", + "ext " + ], + [ + "pr", + "ic" + ], + [ + "-", + "= " + ], + [ + "{", + "\\n function " + ], + [ + ",\\n * ", + "but " + ], + [ + "re", + "fer" + ], + [ + "Cha", + "in" + ], + [ + "t", + "Fee" + ], + [ + "create", + "Pair" + ], + [ + "G", + "en" + ], + [ + "S", + "ale" + ], + [ + ".s", + "ta" + ], + [ + " of ", + "two unsigned integ" + ], + [ + "Set storage ", + "set" + ], + [ + "_", + "safeMint" + ], + [ + "in", + "h" + ], + [ + "decim", + "al" + ], + [ + "Transfer", + "s " + ], + [ + "swap", + "TokensAtAmount" + ], + [ + "super", + "." + ], + [ + "-}[`functionCall`]", + ",\\n * but " + ], + [ + "` and ", + "`" + ], + [ + "1", + "4" + ], + [ + "per", + "mit" + ], + [ + "F", + "actor" + ], + [ + "stand", + "ard " + ], + [ + "throu", + "gh " + ], + [ + ") {\\n ", + "// " + ], + [ + "1", + "5" + ], + [ + "address", + ") {\\n return " + ], + [ + "``", + "`" + ], + [ + "fun", + "d" + ], + [ + "bytes", + "(" + ], + [ + "f", + "y" + ], + [ + "s", + "qrt" + ], + [ + "A", + "N" + ], + [ + "c", + "ess" + ], + [ + "call ", + "failed" + ], + [ + "St", + "and" + ], + [ + "mload", + "(" + ], + [ + "es", + "ired" + ], + [ + "transfer", + "s " + ], + [ + "succeed", + "ed" + ], + [ + "Token", + "Ownership" + ], + [ + ".\\n */\\n ", + "error " + ], + [ + "wh", + "ere " + ], + [ + "posi", + "tion" + ], + [ + "round", + "ing " + ], + [ + "ro", + "yalty" + ], + [ + "1", + "._\\n */\\n function " + ], + [ + "- ", + "1" + ], + [ + "get", + "Approved" + ], + [ + "D", + "i" + ], + [ + "P", + "AR" + ], + [ + "} and ", + "{" + ], + [ + "_", + "F" + ], + [ + "_", + "marketing" + ], + [ + "res", + "p" + ], + [ + "(address ", + "to, uint256 " + ], + [ + "::", + "::" + ], + [ + "Reward", + "s" + ], + [ + ">", + "=" + ], + [ + "] ", + "+= " + ], + [ + "us", + "ed to " + ], + [ + "errorMessage", + "\\n " + ], + [ + "Count", + "er " + ], + [ + "assembly ", + "{\\n " + ], + [ + ",\\n string memory ", + "errorMessage\\n " + ], + [ + "at ", + "the " + ], + [ + "Y", + "P" + ], + [ + ")\\\", p0, p1, p2, p3));\\n\\t}\\n\\n\\tfunction ", + "log(" + ], + [ + "S", + "tor" + ], + [ + "reas", + "on" + ], + [ + "en", + "um" + ], + [ + "ex", + "cluded" + ], + [ + "ff", + "ect" + ], + [ + "'", + "'" + ], + [ + "L", + "O" + ], + [ + "ex", + "traData" + ], + [ + "old", + "Owner" + ], + [ + "fe", + "e " + ], + [ + "deleg", + "ate" + ], + [ + ". O", + "(1" + ], + [ + "s", + "lot " + ], + [ + "to ", + "a " + ], + [ + "reasur", + "y" + ], + [ + "allow", + "ed to " + ], + [ + "renounce", + "Ownership" + ], + [ + "address ", + "of the " + ], + [ + "Safe", + "Cast" + ], + [ + "Role", + "Admin" + ], + [ + "ro", + "y" + ], + [ + "ic", + "ally " + ], + [ + "is ", + "an " + ], + [ + "at", + "es " + ], + [ + "st", + "atu" + ], + [ + "****************", + "****************" + ], + [ + "(", + "token" + ], + [ + "boolean ", + "value " + ], + [ + "B", + "y" + ], + [ + "en", + "cod" + ], + [ + "count", + "er" + ], + [ + "gr", + "am" + ], + [ + "supportsInterfac", + "e" + ], + [ + "indicating ", + "whether the " + ], + [ + "re", + "e" + ], + [ + "Token", + "Id " + ], + [ + "ma", + "pping " + ], + [ + " to ", + "the " + ], + [ + "} event", + ".\\n */\\n function _" + ], + [ + "(", + ");\\n\\n " + ], + [ + "sc", + "al" + ], + [ + "tokenId` must ", + "exist" + ], + [ + ".sta", + "ticcall" + ], + [ + "when ", + "`from" + ], + [ + ");\\n ", + "}" + ], + [ + "Se", + "aDrop" + ], + [ + "operation ", + "succeeded" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `", + "from" + ], + [ + "oun", + "d " + ], + [ + "boolean value ", + "indicating whether the " + ], + [ + "boolean value indicating whether the ", + "operation succeeded" + ], + [ + "\\n ", + "_" + ], + [ + "bytes memory ", + "returndata" + ], + [ + "(address owner, address ", + "spender" + ], + [ + "4", + "8" + ], + [ + "B", + "P" + ], + [ + "s", + "\\n " + ], + [ + "block.", + "number" + ], + [ + ") external", + ";\\n\\n /**\\n * @dev " + ], + [ + "_", + "000" + ], + [ + ".", + "\\n" + ], + [ + "de", + "t" + ], + [ + "s.", + "length" + ], + [ + ";\\n", + "\\t" + ], + [ + "represent", + "ation" + ], + [ + ">= ", + "amount" + ], + [ + "sta", + "tic " + ], + [ + "2", + "8" + ], + [ + "ti", + "es" + ], + [ + "f", + "ilte" + ], + [ + "g", + "i" + ], + [ + "r", + "ant" + ], + [ + "Su", + "b" + ], + [ + "burn", + " " + ], + [ + "Returns a ", + "boolean value indicating whether the operation succeeded" + ], + [ + "per", + "mis" + ], + [ + "send", + " " + ], + [ + "uint256 private ", + "constant _" + ], + [ + "defin", + "ed " + ], + [ + "/", + "\\n " + ], + [ + ",,", + ",," + ], + [ + "edi", + "tion" + ], + [ + "auth", + "or" + ], + [ + "ong", + " " + ], + [ + "prev", + "Ownership" + ], + [ + "A", + "cc" + ], + [ + "Mul", + "ti" + ], + [ + "ent", + "i" + ], + [ + "A", + "l" + ], + [ + "er", + "ation" + ], + [ + "ma", + "ke " + ], + [ + "col", + "lateral" + ], + [ + "h", + "igh" + ], + [ + "a ", + "/ " + ], + [ + "\"", + "Ownable: " + ], + [ + "`tokenId` ", + "token " + ], + [ + "u", + "ction" + ], + [ + "ma", + "p" + ], + [ + "\\r", + "\\n * " + ], + [ + "ov", + "ern" + ], + [ + "p", + "ow" + ], + [ + "} ", + "that " + ], + [ + "execu", + "tion " + ], + [ + "IMPORTANT", + ": " + ], + [ + ") {\\n ", + "_" + ], + [ + "vail", + "able" + ], + [ + "\\n ", + "view" + ], + [ + "amount", + "B" + ], + [ + "` ", + "must be " + ], + [ + "ec", + "im" + ], + [ + "recipient", + ", uint256 amount" + ], + [ + "\\n //", + " " + ], + [ + "ti", + "ve " + ], + [ + "ic", + "ation " + ], + [ + "com", + "put" + ], + [ + "ati", + "ve" + ], + [ + "98", + "1" + ], + [ + "(", + "x" + ], + [ + "{approve", + "} or {" + ], + [ + "the caller ", + "must have " + ], + [ + "d", + "rop" + ], + [ + "e", + "a" + ], + [ + "ma", + "th" + ], + [ + "_r", + "Owned" + ], + [ + "` is zero, ", + "`amount` " + ], + [ + "on\\n * ", + "overflow" + ], + [ + "G", + "N" + ], + [ + "sh", + "a" + ], + [ + "ant", + " " + ], + [ + "set", + ". O(1" + ], + [ + "doc", + "\"" + ], + [ + "ack", + "list" + ], + [ + "6", + "5" + ], + [ + "(account", + ", " + ], + [ + ", ", + "includ" + ], + [ + "uint256 ", + "internal " + ], + [ + "contract ", + "is " + ], + [ + "contract", + "s " + ], + [ + "zero", + ".\\n *\\n * " + ], + [ + "approved", + "Address" + ], + [ + "_max", + "Wallet" + ], + [ + "r", + "Amount" + ], + [ + "er", + "s " + ], + [ + "cont", + "rol" + ], + [ + "_", + "ROLE" + ], + [ + "\\n // ", + "=============================================================" + ], + [ + "tit", + "le " + ], + [ + "msg", + "Data" + ], + [ + "Th", + "res" + ], + [ + "main", + "Se" + ], + [ + "Sta", + "tic" + ], + [ + "b", + "bl" + ], + [ + "` ", + "must have " + ], + [ + "To", + "Swap" + ], + [ + " of two unsigned integ", + "ers, " + ], + [ + "with ", + "`" + ], + [ + "\\n */\\n", + "abstract contract " + ], + [ + "fin", + "al" + ], + [ + "caller is not ", + "the owner" + ], + [ + ").", + "max" + ], + [ + "C", + "an " + ], + [ + "Call", + "ing " + ], + [ + "`target", + "` " + ], + [ + " of the ", + "token" + ], + [ + "sto", + "red " + ], + [ + "`owner", + "` " + ], + [ + "=============================================================", + "\\n // " + ], + [ + ", ", + "errorMessage" + ], + [ + "////", + "//" + ], + [ + "_", + "operator" + ], + [ + "10", + "**" + ], + [ + "(", + "`" + ], + [ + "Re", + "vok" + ], + [ + "bu", + "bbl" + ], + [ + "_", + "msgData" + ], + [ + ") ", + "== " + ], + [ + "Static", + "Call" + ], + [ + "(\\n address ", + "target" + ], + [ + "p", + "rec" + ], + [ + "abi", + "l" + ], + [ + "own", + "ed" + ], + [ + ".sol\\\";\\nimport \\\"", + "../../" + ], + [ + "If ", + "the " + ], + [ + "s a ", + "`" + ], + [ + "inh", + "er" + ], + [ + "c", + "ustom" + ], + [ + "function", + "StaticCall" + ], + [ + "Cont", + "ext " + ], + [ + "{", + "transferFrom" + ], + [ + "O", + "K" + ], + [ + "in", + "clude" + ], + [ + "im", + "its" + ], + [ + "amount", + "1" + ], + [ + "b", + "el" + ], + [ + " ", + "that is " + ], + [ + "el", + "op" + ], + [ + "op", + "tim" + ], + [ + "Contrac", + "t " + ], + [ + "str", + "uction" + ], + [ + "amount", + "0" + ], + [ + "Paus", + "ed" + ], + [ + ");\\r\\n", + "\\r\\n " + ], + [ + "(\\n ", + "uint256 " + ], + [ + "dig", + "its" + ], + [ + ".\\r\\n *", + "\\r\\n * " + ], + [ + "is", + "ter" + ], + [ + "row", + "s " + ], + [ + "cre", + "ated" + ], + [ + "det", + "ail" + ], + [ + "disable", + "-" + ], + [ + "spender", + "` cannot be the zero address" + ], + [ + "rou", + "ter" + ], + [ + "mainSe", + "parator" + ], + [ + "() external view returns (", + "string memory" + ], + [ + "swapExactTokensFor", + "ETHSupportingFeeOnTransferTokens" + ], + [ + "\\\"", + "\\n " + ], + [ + "bytes32 ", + "role" + ], + [ + "Role(", + "bytes32 role" + ], + [ + "swapTokensFor", + "Eth" + ], + [ + "M", + "etadata " + ], + [ + "R", + "R" + ], + [ + "s", + "ue" + ], + [ + ",\\n ", + "uint amount" + ], + [ + "V", + "otes" + ], + [ + "owned by ", + "`from" + ], + [ + "swa", + "pping" + ], + [ + "(", + ") internal view virtual returns (" + ], + [ + "`", + ") " + ], + [ + "cur", + "r" + ], + [ + "re", + "entr" + ], + [ + "\\n * ", + "- " + ], + [ + "L", + "P" + ], + [ + ") {\\n ", + "return " + ], + [ + "AS", + "CI" + ], + [ + "has ", + "been " + ], + [ + ".\\n *\\n * _Available since v3.", + "1._\\n */\\n function " + ], + [ + "` operator", + ".\\n *\\n * Requirements:\\n *\\n * - " + ], + [ + "ASCI", + "I" + ], + [ + "i", + "." + ], + [ + "(address ", + "target, " + ], + [ + "0.", + "5" + ], + [ + "of", + "t" + ], + [ + "mapping(address => ", + "uint256" + ], + [ + "-", + "onERC721Received" + ], + [ + "an", + "other " + ], + [ + "mechanis", + "ms" + ], + [ + "IERC721Receiver", + "-onERC721Received" + ], + [ + "of `", + "`from``'s " + ], + [ + "z", + "e " + ], + [ + "4.", + "_" + ], + [ + "Invalid", + "Signature" + ], + [ + "\"// SPDX-License-Identifier: MIT", + "\\n\\npragma solidity ^0.8.0" + ], + [ + "for", + "m" + ], + [ + "s", + "afe " + ], + [ + "si", + "on " + ], + [ + "Be", + "fo" + ], + [ + "lo", + "b" + ], + [ + "Can", + "not " + ], + [ + "ReentrancyGu", + "ard" + ], + [ + "un", + "i" + ], + [ + "a ", + "contract " + ], + [ + "Con", + "vert" + ], + [ + "wor", + "k" + ], + [ + "the ", + "updated " + ], + [ + "spender", + ", amount" + ], + [ + "be", + "\\n * " + ], + [ + "(address(0), ", + "to, " + ], + [ + "_T", + "YP" + ], + [ + "up", + "grade" + ], + [ + ",\\r\\n ", + "uint256 " + ], + [ + "////////", + "//////" + ], + [ + ", address ", + "account" + ], + [ + "` to ", + "`" + ], + [ + "delet", + "e " + ], + [ + "O", + "L" + ], + [ + "check", + " " + ], + [ + "ra", + "y " + ], + [ + "division ", + "by " + ], + [ + "function", + "Delegate" + ], + [ + "fit ", + "in " + ], + [ + "(address target, ", + "bytes memory data" + ], + [ + "functionDelegate", + "Call" + ], + [ + "(", + "sender" + ], + [ + "(", + "to, " + ], + [ + ". ", + "The " + ], + [ + "quant", + "ity " + ], + [ + "Par", + "am" + ], + [ + "s", + "our" + ], + [ + ", ", + "1" + ], + [ + "sh", + "are" + ], + [ + "se", + "e " + ], + [ + "to", + ", uint256 amount" + ], + [ + "a ", + "balance of at least " + ], + [ + "Ex", + "ceed" + ], + [ + "\\n * ", + "@dev " + ], + [ + "MA", + "IN" + ], + [ + "-", + "assembly" + ], + [ + ".", + "selector" + ], + [ + "_", + "exists" + ], + [ + "con", + "fig" + ], + [ + "pa", + "use" + ], + [ + "fl", + "ag" + ], + [ + "condition", + "s:" + ], + [ + "D", + "iv" + ], + [ + "Man", + "ag" + ], + [ + " that is ", + "called " + ], + [ + "Zero", + "Address" + ], + [ + "Wei", + "ght" + ], + [ + "a balance of at least ", + "`amount" + ], + [ + "V", + "ault" + ], + [ + "_", + "holder" + ], + [ + "solhint-", + "disable-" + ], + [ + "_", + "P" + ], + [ + "e", + "qu" + ], + [ + "us", + "t" + ], + [ + "\"// SPDX-License-Identifier: MIT", + "\\n" + ], + [ + "OK", + "EN" + ], + [ + "elop", + "ment" + ], + [ + "\"", + "\"" + ], + [ + "is", + "\\n * " + ], + [ + "Upgrade", + "able" + ], + [ + "the updated ", + "allowance" + ], + [ + "F", + "l" + ], + [ + "over", + " " + ], + [ + "mo", + "d " + ], + [ + "/", + "*" + ], + [ + "max", + " " + ], + [ + "result ", + "is " + ], + [ + "buy", + "TotalFees" + ], + [ + "&", + " " + ], + [ + "indicating ", + "the updated allowance" + ], + [ + "} event ", + "indicating the updated allowance" + ], + [ + "addLiquidity", + "ETH" + ], + [ + "using", + "-" + ], + [ + "(", + ");\\n\\n " + ], + [ + ") external", + ";\\n\\n " + ], + [ + "total ", + "supply" + ], + [ + "Percent", + "age" + ], + [ + "O", + "MAIN" + ], + [ + "S", + "h" + ], + [ + "to", + "\\n * " + ], + [ + "ac", + "tual" + ], + [ + "Li", + "b" + ], + [ + "and", + "om" + ], + [ + "\\n */\\n", + "interface " + ], + [ + "_token", + "Approval" + ], + [ + "B", + "ack" + ], + [ + "V", + "er" + ], + [ + ");\\n }\\n\\n /**\\n * @dev ", + "See {" + ], + [ + "(\\n address target", + ",\\n bytes memory data" + ], + [ + ": ", + "value " + ], + [ + "value", + "s " + ], + [ + "perform", + "ing a " + ], + [ + "Stor", + "age" + ], + [ + "5", + "d" + ], + [ + "value ", + "of " + ], + [ + "v", + "2" + ], + [ + "b", + "as" + ], + [ + "\\n * ", + "{" + ], + [ + "allow", + "s " + ], + [ + ",\\n ", + "\\\"" + ], + [ + "larg", + "est " + ], + [ + "p", + "er " + ], + [ + "Ma", + "pping " + ], + [ + "` and `to` are ", + "both " + ], + [ + "(\\n address from,\\n address to,\\n uint256 tokenId", + "\\n " + ], + [ + "` and `to` are both ", + "non-" + ], + [ + "eth", + "For" + ], + [ + "u", + "nt" + ], + [ + "ar", + "y " + ], + [ + "Th", + "e" + ], + [ + "Balanc", + "e = " + ], + [ + "*", + "/" + ], + [ + "_", + "B" + ], + [ + ", \\\"Address: ", + "low-level " + ], + [ + "o", + "ff" + ], + [ + "100", + "0" + ], + [ + "Mo", + "ve" + ], + [ + "Calling ", + "conditions:" + ], + [ + "/", + "= " + ], + [ + "amount", + ");\\n\\n " + ], + [ + "check", + "point" + ], + [ + "prod", + "uc" + ], + [ + "2^", + "256" + ], + [ + "hal", + "f " + ], + [ + "ex", + "ce" + ], + [ + "amount", + "A" + ], + [ + "et", + "a" + ], + [ + "pro", + "gram" + ], + [ + ") internal virtual ", + "{" + ], + [ + "U", + "N" + ], + [ + "d", + "istribu" + ], + [ + "able ", + "to " + ], + [ + "ERC2", + "981" + ], + [ + "u", + "ally " + ], + [ + "A", + "n" + ], + [ + "this ", + "contract " + ], + [ + "auto", + "ma" + ], + [ + "(", + "\\r\\n " + ], + [ + " (", + "when the " + ], + [ + "reverting ", + "on\\n * overflow" + ], + [ + "f", + "allback" + ], + [ + "address(this", + ")." + ], + [ + "sto", + "p" + ], + [ + "ar", + "y" + ], + [ + "} ", + "from " + ], + [ + "Paus", + "able" + ], + [ + "access/", + "Ownable" + ], + [ + "h", + "ead" + ], + [ + "re", + "le" + ], + [ + "mint", + "ed" + ], + [ + " == ", + "0" + ], + [ + "previou", + "s " + ], + [ + "Thres", + "hold" + ], + [ + "O", + "PER" + ], + [ + "e", + ": " + ], + [ + "\\n *", + "/\\n " + ], + [ + "!= ", + "address(0), \\\"" + ], + [ + "On", + "ly " + ], + [ + "new ", + "owner" + ], + [ + "M", + "P" + ], + [ + "Ma", + "p" + ], + [ + "next", + "-" + ], + [ + "mint", + " to " + ], + [ + "IUniswapV2", + "Factory" + ], + [ + "c", + "alcul" + ], + [ + "sha", + "res" + ], + [ + "T", + "RA" + ], + [ + "// ", + "=============================================================\\n // " + ], + [ + "lock", + "ed" + ], + [ + "trading", + "Open" + ], + [ + "H", + "old" + ], + [ + "Num", + "ber" + ], + [ + "7", + "8" + ], + [ + "c", + "le" + ], + [ + "able ", + "is " + ], + [ + "Se", + "e " + ], + [ + "uint16", + "0" + ], + [ + "interfaceId == ", + "type(" + ], + [ + "\\", + "ti" + ], + [ + "crease", + "s the " + ], + [ + "Hook", + " that is called " + ], + [ + "amp", + "le" + ], + [ + "(address indexed ", + "owner" + ], + [ + "(msg.sender", + ", " + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `from", + "` cannot be the zero address.\\n * - `" + ], + [ + "o", + "in" + ], + [ + "re", + "r" + ], + [ + "bytes ", + "calldata " + ], + [ + "\\r\\n *", + "/\\r\\n function " + ], + [ + "_", + "ENT" + ], + [ + "mint", + "ing " + ], + [ + "the zero address\\\");\\n\\n ", + "_beforeTokenTransfer" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `", + "to` cannot be the zero address.\\n * - `" + ], + [ + "st", + "ate" + ], + [ + "delegat", + "ee" + ], + [ + "_in", + "itial" + ], + [ + "_S", + "E" + ], + [ + "MIN", + "T" + ], + [ + "////////////////////////////////", + "////////////////" + ], + [ + "D", + "ay" + ], + [ + "I", + "S" + ], + [ + "to", + "\\n * " + ], + [ + "Initializ", + "ed" + ], + [ + "de", + "scri" + ], + [ + "uint256", + "," + ], + [ + "am", + "e" + ], + [ + "au", + "x" + ], + [ + "Us", + "ing " + ], + [ + "minted ", + "for " + ], + [ + "} from ", + "\\\"" + ], + [ + ", ", + "0" + ], + [ + "t", + "x" + ], + [ + "IN", + "IT" + ], + [ + "take", + "Fee" + ], + [ + "(", + "data" + ], + [ + "and ", + "the " + ], + [ + ".", + " " + ], + [ + "S", + "O" + ], + [ + "s", + "ale" + ], + [ + "the", + "\\n * " + ], + [ + "tokenId` ", + "token " + ], + [ + "ti", + "ck" + ], + [ + "is", + "sue" + ], + [ + "se", + "cur" + ], + [ + "it ", + "is " + ], + [ + " b", + "oth " + ], + [ + "sell", + "TotalFees" + ], + [ + "` and `to` are both non-", + "zero, " + ], + [ + "Stand", + "ard" + ], + [ + "next-", + "line " + ], + [ + "C", + "ur" + ], + [ + "data", + ". " + ], + [ + "rol", + "e " + ], + [ + "s", + "ame " + ], + [ + "\\\"", + ");" + ], + [ + "approve", + "(address spender" + ], + [ + ") ", + ">> " + ], + [ + "liquidity", + "Fee" + ], + [ + "(address indexed owner", + ", address indexed " + ], + [ + "b", + "ase " + ], + [ + "prod", + "0" + ], + [ + "30", + "9" + ], + [ + "chang", + "e " + ], + [ + "F", + "in" + ], + [ + "account", + ", amount" + ], + [ + "transfer", + "(address " + ], + [ + "Role(bytes32 role", + ", address account" + ], + [ + "\\n *", + "\\n * - " + ], + [ + "con", + "struction" + ], + [ + "subscri", + "ption" + ], + [ + "royal", + "ty " + ], + [ + ", ", + ") = " + ], + [ + "tokens ", + "are " + ], + [ + "call to ", + "non-" + ], + [ + "Liqui", + "fy" + ], + [ + "all", + "Tokens" + ], + [ + ". This ", + "include" + ], + [ + "while ", + "(" + ], + [ + "requ", + "est" + ], + [ + "SafeCast", + ": value " + ], + [ + "e", + "as" + ], + [ + "k", + "n" + ], + [ + "uint", + "112" + ], + [ + "call", + ".\\n *\\n * _Available since v3." + ], + [ + "as ", + "an " + ], + [ + "-}[`functionCall`],\\n * but ", + "performing a " + ], + [ + "to", + "String" + ], + [ + "ed to ", + "the " + ], + [ + "----------------", + "----------------" + ], + [ + "_buy", + "Count" + ], + [ + "role", + ", " + ], + [ + ") internal returns (bytes memory", + ") {\\n return " + ], + [ + "ER", + "ED" + ], + [ + "con", + "sum" + ], + [ + "se ", + "if (" + ], + [ + "Dev", + "Fee" + ], + [ + "io", + "/" + ], + [ + "call to non-", + "contract" + ], + [ + "_", + "new" + ], + [ + "a", + "vailable" + ], + [ + "mul", + "(" + ], + [ + "keccak256", + "(" + ], + [ + "src", + "/" + ], + [ + "` and `to` are ", + "never" + ], + [ + "Fe", + "e " + ], + [ + "` and `to` are never", + " both " + ], + [ + "l", + "ang" + ], + [ + "import ", + "{" + ], + [ + "Query", + "For" + ], + [ + "Calling conditions:", + "\\n *\\n * - " + ], + [ + "4", + "6" + ], + [ + "T", + "ION" + ], + [ + "(address account", + ", uint256 amount" + ], + [ + "I", + "AL" + ], + [ + "Address", + "Data" + ], + [ + "star", + "t " + ], + [ + "`, ", + "it " + ], + [ + "(address(0), ", + "account, amount" + ], + [ + "automatedMarketMakerPair", + "s" + ], + [ + "Gen", + "er" + ], + [ + "um", + "ul" + ], + [ + ") external ", + "returns (" + ], + [ + "token/ERC20/", + "extensions/" + ], + [ + ", uint256 ", + "value" + ], + [ + "\\n *\\n * ", + "This " + ], + [ + "ed by ", + "the " + ], + [ + "OO", + "OO" + ], + [ + "de", + "code" + ], + [ + "wa", + "y" + ], + [ + "(uint256 value", + ") internal pure returns (" + ], + [ + "Chain", + "Id" + ], + [ + "s", + "o " + ], + [ + "ERC721", + "Receiver" + ], + [ + "` is ", + "the " + ], + [ + "9", + "9" + ], + [ + "on", + "e" + ], + [ + "from", + "` and `to` are never both " + ], + [ + "Typ", + "e" + ], + [ + "solhint-disable-", + "next-line " + ], + [ + "INIT", + "IAL" + ], + [ + ");\\n ", + "uint256 " + ], + [ + "se", + "c" + ], + [ + "appro", + "v" + ], + [ + "(account, ", + "address(0), " + ], + [ + "y", + "-" + ], + [ + "value", + ": " + ], + [ + "(address ", + "from" + ], + [ + "} else {", + "\\n " + ], + [ + "downcast", + "ed " + ], + [ + "us", + "e {" + ], + [ + "approve", + "}" + ], + [ + "in", + "iti" + ], + [ + "_owner", + "ship" + ], + [ + "div", + "(" + ], + [ + ", ", + "r" + ], + [ + "value ", + "is " + ], + [ + "EIP", + "712" + ], + [ + "hash", + " " + ], + [ + " - ", + "1" + ], + [ + " = 0", + "; i" + ], + [ + "er", + "y " + ], + [ + "marketing", + "Wallet" + ], + [ + "try", + "Recover" + ], + [ + "Or", + "Owner" + ], + [ + " ", + "not " + ], + [ + "_", + "uniswapV2Router" + ], + [ + "doesn't ", + "fit in " + ], + [ + "SafeCast: value ", + "doesn't fit in " + ], + [ + "address ", + "public " + ], + [ + "(uint256 ", + "=> " + ], + [ + "amount exceeds ", + "allowance" + ], + [ + "Acc", + "ount" + ], + [ + "D", + "esired" + ], + [ + "FeeOn", + "Sell" + ], + [ + "reward", + "s" + ], + [ + "A", + "B" + ], + [ + "C", + "op" + ], + [ + "al", + "tern" + ], + [ + "call", + "ing " + ], + [ + ");\\n ", + "}\\n }\\n\\n /**\\n * @dev " + ], + [ + ") public virtual override ", + "returns (bool) {\\n " + ], + [ + "r", + "un" + ], + [ + "tokenId", + "s" + ], + [ + "contract", + "Balance" + ], + [ + "P", + "ri" + ], + [ + "g", + "lob" + ], + [ + "\\n ", + "uint256 " + ], + [ + "Fee", + "Receiver" + ], + [ + "string", + "` " + ], + [ + "max", + "Transaction" + ], + [ + "() external view returns (", + "uint256" + ], + [ + "Ex", + "t" + ], + [ + "ra", + "ti" + ], + [ + ".sol\\\";\\nimport \\\"", + "@openzeppelin/contracts/" + ], + [ + "lang", + "u" + ], + [ + "3", + "._\\n */\\n function " + ], + [ + "re", + "de" + ], + [ + "- ", + "amount" + ], + [ + " `", + "string` " + ], + [ + "E", + "nd" + ], + [ + "s ", + "with " + ], + [ + "reg", + "ister" + ], + [ + "_transferOwnership", + "(" + ], + [ + "incre", + "ment" + ], + [ + "subtr", + "action" + ], + [ + "> ", + "0" + ], + [ + "a", + "vo" + ], + [ + "is", + "Excluded" + ], + [ + "_tax", + "Wallet" + ], + [ + "i", + "de" + ], + [ + "s", + "o" + ], + [ + "If ", + "the call" + ], + [ + "amountETH", + "Min" + ], + [ + "amountToken", + "Min" + ], + [ + "transferred to ", + "`to`.\\n * - " + ], + [ + "remove", + "Liquidity" + ], + [ + "altern", + "ative " + ], + [ + "es", + ": " + ], + [ + "ar", + "ray " + ], + [ + "supp", + "ort " + ], + [ + "ing ", + "to " + ], + [ + ");\\n ", + "event " + ], + [ + "set._", + "in" + ], + [ + "Sha", + "re" + ], + [ + "ASCII", + " `string` " + ], + [ + "vide", + "s " + ], + [ + "bel", + "ow " + ], + [ + "se", + "e {" + ], + [ + "non", + "ces" + ], + [ + ".\\n *\\n * Emits an {Approval", + "} event indicating the updated allowance" + ], + [ + "uint256 internal ", + "constant " + ], + [ + "spec", + "ifi" + ], + [ + "address", + "es" + ], + [ + "re ", + "the " + ], + [ + "ra", + "pp" + ], + [ + "resp", + "ond" + ], + [ + "Befo", + "re" + ], + [ + "minted for ", + "`to`.\\n * - " + ], + [ + " ", + "The " + ], + [ + " *", + "* " + ], + [ + "LE", + "_ADDRESS" + ], + [ + "_", + "final" + ], + [ + "\\n * ", + "@param _" + ], + [ + "el", + "d" + ], + [ + ");\\n", + " " + ], + [ + "0", + ";\\n " + ], + [ + "e", + "18" + ], + [ + "co", + "ve" + ], + [ + "Co", + "m" + ], + [ + "; i", + "++" + ], + [ + "Rem", + "o" + ], + [ + "use", + "s " + ], + [ + "CON", + "SO" + ], + [ + "4._", + "\\n */\\n function " + ], + [ + "CONSO", + "LE_ADDRESS" + ], + [ + "\\n *", + " " + ], + [ + "Th", + "rows " + ], + [ + "== ", + "0) {\\n " + ], + [ + "tar", + "get " + ], + [ + "Rec", + "ipient" + ], + [ + "openzeppelin", + "-" + ], + [ + "ig", + "nored" + ], + [ + "[] ", + "memory" + ], + [ + "man", + "age " + ], + [ + ";\\n\\t", + "}\\n\\n\\tfunction " + ], + [ + "2", + "00" + ], + [ + "ing", + "." + ], + [ + "override ", + "returns (bool" + ], + [ + "transfer to ", + "the zero address\"" + ], + [ + "mart ", + "contract" + ], + [ + "_TYP", + "E" + ], + [ + "af", + "ely " + ], + [ + "iz", + "ed" + ], + [ + " ", + "&& " + ], + [ + "UR", + "N" + ], + [ + "Chang", + "ed" + ], + [ + ", it ", + "must " + ], + [ + "8", + "4" + ], + [ + "_", + "packedOwnership" + ], + [ + "g", + "h" + ], + [ + "is", + "su" + ], + [ + "qu", + "ery " + ], + [ + "With", + "draw" + ], + [ + "permis", + "sion" + ], + [ + "Returns true ", + "if the " + ], + [ + "PAR", + "ATOR" + ], + [ + "ERC165", + " " + ], + [ + "Po", + "int" + ], + [ + "decre", + "ased " + ], + [ + "mint", + "er" + ], + [ + "Registr", + "y" + ], + [ + "ol", + "d " + ], + [ + "current", + "Rate" + ], + [ + "cor", + "rect" + ], + [ + "{\\n ", + "// " + ], + [ + "lea", + "ves" + ], + [ + " overflow", + "\"" + ], + [ + "new owner", + " is " + ], + [ + "address", + "[] calldata " + ], + [ + "con", + "c" + ], + [ + "\\n\\n", + " " + ], + [ + "));\\n\\t", + "\\ti" + ], + [ + ".\\n */\\n", + "interface " + ], + [ + ",", + "uint256 " + ], + [ + "1", + "3" + ], + [ + "S", + "tart" + ], + [ + "g", + "nored" + ], + [ + "si", + "ze " + ], + [ + ") internal view {\\n\\t\\t", + "(bool " + ], + [ + ".staticcall", + "(abi.encodeWithSignature(\\\"log(" + ], + [ + "\\n // =============================================================", + "\\n\\n /**\\n * @dev " + ], + [ + "OMAIN", + "_SE" + ], + [ + ", ) = ", + "CONSOLE_ADDRESS" + ], + [ + "ignored", + ", ) = CONSOLE_ADDRESS" + ], + [ + "));\\n\\t\\ti", + "gnored" + ], + [ + ") internal view {\\n\\t\\t(bool ", + "ignored, ) = CONSOLE_ADDRESS" + ], + [ + "OMAIN_SE", + "PARATOR" + ], + [ + ") internal view {\\n\\t\\t(bool ignored, ) = CONSOLE_ADDRESS", + ".staticcall(abi.encodeWithSignature(\\\"log(" + ], + [ + "U", + "P" + ], + [ + "balanceOf", + "(address account" + ], + [ + "only be ", + "called by " + ], + [ + "() external view returns (string memory", + ");\\n\\n /**\\n * @dev Returns the " + ], + [ + "uc", + "e" + ], + [ + ".\\n * ", + "@param " + ], + [ + "or", + "ac" + ], + [ + "mapping", + "(uint256 => " + ], + [ + "ch", + "ed" + ], + [ + "interfac", + "es" + ], + [ + "();\\n\\n ", + "/**\\n * " + ], + [ + "));\\n\\t\\tignored", + ";\\n\\t}\\n\\n\\tfunction " + ], + [ + "(address ", + "_" + ], + [ + "packed", + "AddressData" + ], + [ + "G", + "rant" + ], + [ + "[owner", + "][spender" + ], + [ + "N", + "ew" + ], + [ + "_", + "IN" + ], + [ + "Au", + "tomatedMarketMakerPair" + ], + [ + "\\n * @", + "title " + ], + [ + "w", + "is" + ], + [ + "tu", + "p" + ], + [ + "⣿", + "⣿" + ], + [ + ".\\n *\\n * ", + "Calling conditions:\\n *\\n * - " + ], + [ + "\\t", + "\\t" + ], + [ + "ter", + "m" + ], + [ + "allowance ", + "below " + ], + [ + ".\\r\\n *", + "/\\r\\n function " + ], + [ + "excludeFrom", + "MaxTransaction" + ], + [ + "decreased ", + "allowance below " + ], + [ + "er", + "t" + ], + [ + "ing", + "le " + ], + [ + "R", + "ati" + ], + [ + "uint ", + "deadline" + ], + [ + "returndata", + "_" + ], + [ + "P", + "re" + ], + [ + "or", + "d" + ], + [ + ") external view returns (", + "bool" + ], + [ + "io", + "d" + ], + [ + "\"@openzeppelin/contracts/", + "utils/" + ], + [ + "the zero address", + "\\\");\\n require(" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `", + "tokenId` must exist" + ], + [ + "prevent", + " " + ], + [ + "2", + "24" + ], + [ + "c", + "ase " + ], + [ + "pragma solidity ", + ">=" + ], + [ + "AT", + "A" + ], + [ + ";\\n\\n // ", + "Mapping " + ], + [ + "De", + "f" + ], + [ + "(address spender", + ", uint256 " + ], + [ + "Returns true ", + "if " + ], + [ + "\\n", + "//" + ], + [ + "from", + ", address indexed " + ], + [ + "call", + "s to " + ], + [ + "It ", + "will " + ], + [ + "d", + "if" + ], + [ + "\\n\\n ", + "function " + ], + [ + "allowance", + "(address owner, address spender" + ], + [ + "\\r\\n *", + "\\r\\n * " + ], + [ + "return", + "ed " + ], + [ + "eth", + "Balance" + ], + [ + "way ", + "to " + ], + [ + "(", + "))" + ], + [ + "s", + "]" + ], + [ + " > 0", + ") {\\n value " + ], + [ + ";\\n }\\n if (value ", + ">> " + ], + [ + "approve(address spender", + ", uint256 amount" + ], + [ + " > 0) {\\n value ", + ">>= " + ], + [ + "o", + "o" + ], + [ + "10", + " ** " + ], + [ + "uint8 ", + "v" + ], + [ + "math", + "/" + ], + [ + "Can ", + "only be called by " + ], + [ + "uint", + "24" + ], + [ + "set ", + "to " + ], + [ + "is", + "h" + ], + [ + ".\\n *\\n * ", + "IMPORTANT: " + ], + [ + "Pro", + "xy" + ], + [ + "man", + "ag" + ], + [ + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"", + "../" + ], + [ + ",", + "\\r\\n " + ], + [ + "I", + "Z" + ], + [ + "M", + "ask" + ], + [ + "Ex", + "empt" + ], + [ + "returndata", + ", errorMessage" + ], + [ + "s", + "mall" + ], + [ + "allowance ", + "of `" + ], + [ + "inver", + "se" + ], + [ + "specif", + "ic " + ], + [ + "ar", + "ant" + ], + [ + "() public view virtual override returns (", + "string memory) {\\n return " + ], + [ + "ic", + "t " + ], + [ + "\\\"", + ");\\r\\n " + ], + [ + "owned", + "Tokens" + ], + [ + "i.", + "e. " + ], + [ + " <", + "= " + ], + [ + "Public", + " " + ], + [ + "_", + "dev" + ], + [ + "\\r\\n ", + " * " + ], + [ + "maximum", + " " + ], + [ + "////////////////////////////////////////////////", + "//////////////" + ], + [ + "M", + "erkle" + ], + [ + ", ", + "as " + ], + [ + "s ", + "of the " + ], + [ + ".sol", + "'" + ], + [ + "\\\\x", + "8" + ], + [ + "maxTransaction", + "Amount" + ], + [ + "D", + "ata " + ], + [ + "N", + "ING" + ], + [ + "ing ", + "all " + ], + [ + "overflow", + " " + ], + [ + "when", + "Not" + ], + [ + "WAR", + "NING" + ], + [ + "[", + "to" + ], + [ + "actual", + " " + ], + [ + "I", + "s" + ], + [ + "0x", + "7" + ], + [ + "_allowances", + "[owner][spender" + ], + [ + "round", + "ed " + ], + [ + "inher", + "it" + ], + [ + "pro", + "cess" + ], + [ + ";\\n", + "\\n // " + ], + [ + "implement", + "ation " + ], + [ + "r", + "Fee" + ], + [ + "ad", + "oc" + ], + [ + ": ", + "invalid " + ], + [ + "if ", + "it " + ], + [ + ").", + "\\n * " + ], + [ + "xref", + ":" + ], + [ + ".\\n */\\n", + "abstract contract " + ], + [ + "];\\n ", + "require(" + ], + [ + " ", + "may " + ], + [ + ")", + "\\n" + ], + [ + "2", + "3" + ], + [ + ");\\n\\n /**\\n * @dev ", + "Emitted when " + ], + [ + "immut", + "able" + ], + [ + "equ", + "al" + ], + [ + "_TYPE", + "HASH" + ], + [ + "s", + "al" + ], + [ + "........", + "........" + ], + [ + "stand", + "ard" + ], + [ + "a s", + "mart contract" + ], + [ + "librar", + "i" + ], + [ + "supportsInterface(bytes4 interfaceId", + ") public view virtual " + ], + [ + "ffffffff", + "ffffffff" + ], + [ + "When ", + "`from" + ], + [ + "ist", + "e" + ], + [ + "keccak256", + "(abi.encode" + ], + [ + "B", + "ot" + ], + [ + "h", + "ow " + ], + [ + "y", + "/" + ], + [ + "S", + "D" + ], + [ + "out", + "put" + ], + [ + "over", + " the " + ], + [ + "Au", + "th" + ], + [ + "Bytes", + "32" + ], + [ + "as the ", + "allowance of `" + ], + [ + "(address to, uint256 ", + "tokenId" + ], + [ + "s", + "a" + ], + [ + "}", + "\\n * " + ], + [ + "mo", + "ve " + ], + [ + ". This ", + "is " + ], + [ + "deploy", + "ed" + ], + [ + "the current ", + "owner" + ], + [ + "ever", + " " + ], + [ + "Def", + "ault" + ], + [ + "as the allowance of `", + "spender` " + ], + [ + "` to ", + "the " + ], + [ + " + ", + "1" + ], + [ + "Solidity ", + "function " + ], + [ + "all", + "y, " + ], + [ + "(bool success, ", + "bytes memory returndata" + ], + [ + "owned by `from", + "`.\\n * - " + ], + [ + "burn", + "ing" + ], + [ + "ERC2", + "309" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `", + "tokenId` token " + ], + [ + "descri", + "b" + ], + [ + "langu", + "age" + ], + [ + "et", + "c" + ], + [ + "`target` ", + "revert" + ], + [ + "em", + "its " + ], + [ + "cor", + "respond" + ], + [ + "\"ERC20: transfer ", + "from the zero address\"" + ], + [ + "li", + "qui" + ], + [ + "ownership", + "." + ], + [ + "M", + "em" + ], + [ + "c", + "y" + ], + [ + "d", + "ay" + ], + [ + "ar", + "ith" + ], + [ + "amount", + ";\\n " + ], + [ + "\"ERC20: ", + "transfer to the zero address\"" + ], + [ + "e", + "re" + ], + [ + "k", + "ee" + ], + [ + "s", + "` " + ], + [ + "\\n ", + "* " + ], + [ + ");\\n ", + "}\\n\\n " + ], + [ + "them", + " " + ], + [ + "n", + "orm" + ], + [ + "refer", + "s to " + ], + [ + "Interfac", + "e " + ], + [ + "(", + "to" + ], + [ + "F", + "5" + ], + [ + "L", + "I" + ], + [ + "h", + "ow" + ], + [ + "Del", + "ay" + ], + [ + "Paus", + "er" + ], + [ + "l", + "icen" + ], + [ + "} ", + "to " + ], + [ + "import ", + "'" + ], + [ + "R", + "Y" + ], + [ + "(address ", + "newOwner" + ], + [ + "a s", + "ingle " + ], + [ + "Int", + "ernal " + ], + [ + "start", + "Timestamp" + ], + [ + "oul", + "d" + ], + [ + "vid", + "end" + ], + [ + "IT", + "Y" + ], + [ + "def", + "ault " + ], + [ + "ne", + "ed to " + ], + [ + "_approve", + "(owner, " + ], + [ + "t", + "Team" + ], + [ + "en", + "su" + ], + [ + "or", + "row" + ], + [ + "ing", + "Factor" + ], + [ + "\\\");\\n ", + "unchecked {\\n " + ], + [ + ";\\n ", + "uint256 internal constant " + ], + [ + "` to ", + "its " + ], + [ + "Con", + "fig" + ], + [ + "DE", + "F" + ], + [ + "Convert", + "s a `" + ], + [ + "divid", + "ing " + ], + [ + ".\\n */\\n function ", + "name" + ], + [ + ".\\n */\\n function ", + "symbol" + ], + [ + "] = ", + "_" + ], + [ + ".\\n */\\n ", + "constructor(" + ], + [ + "informa", + "tion " + ], + [ + ", ", + "b" + ], + [ + "\\n ", + "uint256 " + ], + [ + "co", + "st" + ], + [ + "-", + "contracts." + ], + [ + "D", + "est" + ], + [ + "m", + "edi" + ], + [ + "ad", + "d " + ], + [ + "_total", + "Supply " + ], + [ + "Di", + "vidend" + ], + [ + "-contracts.", + "adoc" + ], + [ + "O", + "rac" + ], + [ + "a", + "un" + ], + [ + "p", + "tr" + ], + [ + "ma", + "in " + ], + [ + " {\\n /**\\n * @dev ", + "Returns the " + ], + [ + ", ", + "IERC20" + ], + [ + "an ", + "owner" + ], + [ + ";\\n\\n // ", + "The " + ], + [ + "b", + "ound" + ], + [ + "imp", + "os" + ], + [ + "own", + " " + ], + [ + ";\\n\\nimport \\\"", + "./" + ], + [ + "]", + "\\n * " + ], + [ + ",\\n ", + "bytes memory " + ], + [ + "\\n\\t", + " *" + ], + [ + "` to its ", + "ASCII `string` " + ], + [ + "%", + " " + ], + [ + "for ", + "a " + ], + [ + "Pack", + "ed(" + ], + [ + "v", + "ot" + ], + [ + "Transfer", + "(address indexed " + ], + [ + "\\n */\\n", + "library " + ], + [ + "RO", + "OT" + ], + [ + "at le", + "ast" + ], + [ + "Can only be called by ", + "the current owner" + ], + [ + "_", + "projectId" + ], + [ + "f", + "ic" + ], + [ + "us", + "ually " + ], + [ + "account", + "Balance" + ], + [ + ") {\\r\\n ", + "return " + ], + [ + "ver", + "t " + ], + [ + "internal ", + "function is " + ], + [ + "contract ", + "without " + ], + [ + "next", + "TokenId" + ], + [ + "internal function is ", + "equivalent to " + ], + [ + "{", + "ERC20" + ], + [ + ");\\n ", + "if (" + ], + [ + "allowanc", + "e(" + ], + [ + "log", + "(address " + ], + [ + "send", + "Value" + ], + [ + "tokensFor", + "Liquidity" + ], + [ + "{IERC20-", + "approve}" + ], + [ + "swap", + " " + ], + [ + ").\\n *\\n * ", + "Counterpart to Solidity's `" + ], + [ + "S", + "y" + ], + [ + "f", + "als" + ], + [ + "abl", + "es " + ], + [ + "should ", + "be " + ], + [ + "writ", + "e" + ], + [ + "_D", + "ATA" + ], + [ + "fix", + "ed " + ], + [ + "6", + "0" + ], + [ + "U", + " " + ], + [ + "- ", + "the " + ], + [ + ");\\n }\\n\\n /**\\n * @dev ", + "Transfers " + ], + [ + ",\\n uint256 ", + "value" + ], + [ + "`account", + "`, " + ], + [ + ",\\r\\n ", + "address " + ], + [ + "P", + "res" + ], + [ + "Mo", + "d" + ], + [ + "amount exceeds balance", + "\"" + ], + [ + "Dest", + "roy" + ], + [ + "m", + "l" + ], + [ + "soli", + "dity " + ], + [ + "BITPOS", + "_N" + ], + [ + "If ", + "`to` " + ], + [ + "Gener", + "al " + ], + [ + "a smart contract", + ", it must " + ], + [ + "refers to ", + "a smart contract, it must " + ], + [ + "If `to` ", + "refers to a smart contract, it must " + ], + [ + "view ", + "override returns (" + ], + [ + "Sign", + "ed" + ], + [ + "sell", + "LiquidityFee" + ], + [ + ".", + "\\n * - " + ], + [ + "_", + "add" + ], + [ + "i", + "dent" + ], + [ + ", address ", + "p1" + ], + [ + "bool ", + "p1" + ], + [ + "string memory ", + "p1" + ], + [ + "p0", + ", address p1" + ], + [ + "p0, ", + "bool p1" + ], + [ + "p0, ", + "string memory p1" + ], + [ + "GN", + "U " + ], + [ + "// ", + "The " + ], + [ + "DEF", + "AU" + ], + [ + "re", + "cove" + ], + [ + "ar", + "ound " + ], + [ + "Base", + "URI" + ], + [ + "informa", + "tion" + ], + [ + "call", + "{" + ], + [ + "On", + "ERC721Received" + ], + [ + "\\\\x", + "e" + ], + [ + "MaxTransaction", + "Amount" + ], + [ + "Cre", + "ator" + ], + [ + "S", + "napshot" + ], + [ + "uint256 ", + "result = " + ], + [ + "_red", + "uce" + ], + [ + "ZZZZ", + "ZZZZ" + ], + [ + "Transfer(address indexed ", + "from, address indexed " + ], + [ + "the ", + "`" + ], + [ + "a ", + "`" + ], + [ + "(address ", + "registrant" + ], + [ + ");\\n ", + "error " + ], + [ + "If the call", + "er is not " + ], + [ + "xref:", + "ROOT" + ], + [ + "xref:ROOT", + ":" + ], + [ + "B", + "y " + ], + [ + "`", + ").\\n *\\n * " + ], + [ + "Se", + "e the " + ], + [ + "[", + "]" + ], + [ + "_", + "EX" + ], + [ + ") ", + "+ " + ], + [ + "prod", + "1" + ], + [ + "Move", + "s `amount` tokens from " + ], + [ + "openzeppelin-", + "contracts/" + ], + [ + "General ", + "Public " + ], + [ + "em", + "s " + ], + [ + "and ", + "burning" + ], + [ + "ETH", + "Balance" + ], + [ + "of `", + "owner" + ], + [ + "(bool success, bytes memory returndata", + ") = " + ], + [ + "describ", + "ed in " + ], + [ + "-", + "safe" + ], + [ + "c", + " = " + ], + [ + "uint256", + "` to its ASCII `string` " + ], + [ + "or", + "igin" + ], + [ + "fee", + "s " + ], + [ + "__", + "__" + ], + [ + "next", + "Initialized" + ], + [ + "role, ", + "account" + ], + [ + "Converts a `", + "uint256` to its ASCII `string` " + ], + [ + " to ", + "`to" + ], + [ + "ownerOf", + "(tokenId" + ], + [ + "OperatorF", + "ilte" + ], + [ + "secur", + "ity" + ], + [ + "initi", + "al " + ], + [ + "[", + "from" + ], + [ + ".\\n */\\n ", + "modifier " + ], + [ + "EIP", + "-" + ], + [ + ">= amount", + ", \\\"ERC20: " + ], + [ + "p", + "t " + ], + [ + "_msgSender", + "ERC721A" + ], + [ + ", s", + "o " + ], + [ + " != address(0), \\\"ERC20: ", + "approve " + ], + [ + "head", + " to " + ], + [ + "se", + "tup" + ], + [ + "that ", + "can be " + ], + [ + "reverting on\\n * overflow", + " (when the " + ], + [ + "0", + "d" + ], + [ + "vi", + "de " + ], + [ + "returns", + "(" + ], + [ + "memory", + "-safe" + ], + [ + "the caller", + "'s " + ], + [ + "solidity ", + "memory-safe" + ], + [ + "(bool success, bytes memory returndata) = ", + "target" + ], + [ + "solidity memory-safe", + "-assembly" + ], + [ + "all", + "y-" + ], + [ + "div", + "is" + ], + [ + "FeeOn", + "Buy" + ], + [ + "} el", + "se if (" + ], + [ + "ht", + "ml" + ], + [ + "To ", + "learn more about " + ], + [ + "metadata", + "\"" + ], + [ + "GNU ", + "General Public " + ], + [ + "u", + "ri" + ], + [ + "low", + " " + ], + [ + "which is ", + "called " + ], + [ + "}, ", + "which is called " + ], + [ + "IERC721Receiver-onERC721Received", + "}, which is called " + ], + [ + "\"", + "metadata\"" + ], + [ + "re", + "l" + ], + [ + "as", + "sum" + ], + [ + "Transfer", + " " + ], + [ + ". ", + "Th" + ], + [ + "\\r\\n", + "\\r\\n" + ], + [ + "\\r\\n ", + " " + ], + [ + "St", + "ate" + ], + [ + "hook", + "s, " + ], + [ + "possible ", + "to " + ], + [ + ".", + "\\n * " + ], + [ + "an", + "y" + ], + [ + "`from", + "`, it " + ], + [ + "Pro", + "tocol" + ], + [ + "enabled", + "\"" + ], + [ + "pur", + "pos" + ], + [ + "custom", + " " + ], + [ + "If the caller is not ", + "`from`, it " + ], + [ + "(", + "), " + ], + [ + "\\n ", + "if (" + ], + [ + "un", + "able to " + ], + [ + "bool", + " _" + ], + [ + "ab", + "o" + ], + [ + "this ", + "method " + ], + [ + "param", + "et" + ], + [ + "Wh", + "itelist" + ], + [ + "Initializ", + "es the " + ], + [ + "I", + "L" + ], + [ + " is ", + "not " + ], + [ + "Set", + "s the " + ], + [ + "/// @", + "solidity memory-safe-assembly" + ], + [ + "Rati", + "o" + ], + [ + "\\\");\\n ", + "_" + ], + [ + "call failed", + "\\\"" + ], + [ + "using-", + "hook" + ], + [ + "Using ", + "Hook" + ], + [ + "head to ", + "xref:ROOT:" + ], + [ + "To learn more about ", + "hooks, " + ], + [ + "To learn more about hooks, ", + "head to xref:ROOT:" + ], + [ + "abi.", + "decode" + ], + [ + "e", + "ffect" + ], + [ + "u", + "re" + ], + [ + "en", + "e" + ], + [ + "ETH", + "To" + ], + [ + "}\\n", + "\\n // " + ], + [ + ") public view virtual ", + "returns (" + ], + [ + "\\u003", + "e " + ], + [ + "by ", + "either " + ], + [ + "token ", + "is " + ], + [ + "s.", + "io/" + ], + [ + "ix", + "ed" + ], + [ + "up", + "on " + ], + [ + "mak", + "ing " + ], + [ + "{approve} or {", + "setApprovalForAll" + ], + [ + "recove", + "red" + ], + [ + "by either ", + "{approve} or {setApprovalForAll" + ], + [ + "(address from", + ", address " + ], + [ + "r", + "ang" + ], + [ + "ext", + "ending" + ], + [ + "overri", + "d" + ], + [ + ");\\n ", + "}\\n " + ], + [ + "transaction", + " " + ], + [ + "\\n * ", + "function " + ], + [ + "bl", + "e " + ], + [ + "with ", + "{" + ], + [ + ").", + "interfaceId " + ], + [ + "\\n\\t", + " * " + ], + [ + ", string memory ", + "errorMessage" + ], + [ + "for (uint256 i", + " = 0; i" + ], + [ + ", recipient", + ", amount" + ], + [ + "#", + "using-hook" + ], + [ + ", ", + "v" + ], + [ + "(address ", + "operator" + ], + [ + "pro", + "xy" + ], + [ + ", address ", + "p2" + ], + [ + "s[", + "Using Hook" + ], + [ + ", string memory ", + "p2" + ], + [ + "(uint256 tokenId", + ") external view returns (" + ], + [ + ", bool ", + "p2" + ], + [ + "mechanism", + " " + ], + [ + "-contracts.adoc", + "#using-hook" + ], + [ + "To learn more about hooks, head to xref:ROOT:", + "extending" + ], + [ + "-contracts.adoc#using-hook", + "s[Using Hook" + ], + [ + "To learn more about hooks, head to xref:ROOT:extending", + "-contracts.adoc#using-hooks[Using Hook" + ], + [ + "_", + "allTokens" + ], + [ + "et", + "we" + ], + [ + ");\\n }\\n\\n ", + "/**\\n * @notice " + ], + [ + "erc", + "20" + ], + [ + ".", + "\\n " + ], + [ + "V", + "ER" + ], + [ + "call", + "er " + ], + [ + "sh", + "ould" + ], + [ + "pay", + "ment" + ], + [ + "(\\n address from,\\n address to,\\n uint256 ", + "amount\\n " + ], + [ + "c", + "ap" + ], + [ + "nam", + "e of the " + ], + [ + "on ", + "be" + ], + [ + ";\\n ", + "uint256 public " + ], + [ + "].", + "\\n *\\n * " + ], + [ + "Y", + "ou " + ], + [ + "}", + "\\n " + ], + [ + "\\\"", + ", \\\"" + ], + [ + "In", + "variant" + ], + [ + "Sta", + "ke" + ], + [ + "gu", + "arant" + ], + [ + "3", + "4" + ], + [ + "en", + "ce" + ], + [ + ", ", + "we " + ], + [ + "address ", + "to " + ], + [ + "Call", + "er" + ], + [ + "log", + "2" + ], + [ + "pl", + "ay" + ], + [ + "address owner = ", + "_msgSender(" + ], + [ + "enum", + "er" + ], + [ + "(data", + ");\\n return " + ], + [ + "el", + "l" + ], + [ + "ag", + "ain" + ], + [ + "require(", + "b" + ], + [ + "com", + "m" + ], + [ + "Set", + "s `amount` " + ], + [ + "admin", + "Role" + ], + [ + "_r", + "Total" + ], + [ + "0.6", + ".0" + ], + [ + "`tokenId` token ", + "from `from` to `to" + ], + [ + "_maxWallet", + "Size" + ], + [ + "_", + "startTokenId" + ], + [ + "set", + "ting " + ], + [ + "denominator", + " * " + ], + [ + "success, ", + "returndata, errorMessage" + ], + [ + "Sets `amount` ", + "as the allowance of `spender` " + ], + [ + "N", + "ame" + ], + [ + ") external view returns (uint256", + ");\\n\\n /**\\n * @dev " + ], + [ + ")", + "," + ], + [ + "3", + "c" + ], + [ + "G", + "overn" + ], + [ + "Pr", + "ic" + ], + [ + ");\\n }\\n\\n /**\\n * @dev See {", + "IERC721-" + ], + [ + "<", + " _" + ], + [ + "public ", + "constant " + ], + [ + "`", + "index" + ], + [ + "c", + "er" + ], + [ + "s", + "napshot" + ], + [ + "st", + "em" + ], + [ + "that ", + "a " + ], + [ + "burn", + " from " + ], + [ + "{\\n ", + "/**\\n * @dev " + ], + [ + "Burn", + "able" + ], + [ + ".\\n *\\n * Emits a {Transfer", + "} event " + ], + [ + "divisi", + "on" + ], + [ + "WARNING", + ": " + ], + [ + "] = ", + "true" + ], + [ + "Interfac", + "e" + ], + [ + "supportsInterface(", + "interfaceId" + ], + [ + "call failed\\\"", + ");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes" + ], + [ + "\\n ", + "override" + ], + [ + "tion", + "al" + ], + [ + "index", + " " + ], + [ + "par", + "t " + ], + [ + "tokens ", + "and " + ], + [ + "tokens ", + "will be " + ], + [ + "updat", + "ed" + ], + [ + " of the ", + "contract " + ], + [ + "c", + "ase" + ], + [ + "string", + "(" + ], + [ + "Sha", + "res" + ], + [ + "DEFAU", + "LT" + ], + [ + "R", + "ed" + ], + [ + "mem", + "ber" + ], + [ + "get", + "Amount" + ], + [ + "string memory", + ") {\\n " + ], + [ + "may ", + "be " + ], + [ + "grant", + "Role" + ], + [ + ";\\r\\n", + "\\r\\n " + ], + [ + "direct", + "ly " + ], + [ + "so", + "me" + ], + [ + "Approval", + "(address indexed owner, address indexed " + ], + [ + "ap", + "h" + ], + [ + "fit ", + "into " + ], + [ + "s ", + "and " + ], + [ + "ro", + "ot" + ], + [ + "\\\"", + "0" + ], + [ + "ch", + "ain " + ], + [ + "low", + "er " + ], + [ + ".\\n ", + "uint256 private constant _" + ], + [ + "For ", + "a " + ], + [ + "u", + "al" + ], + [ + "u", + "pp" + ], + [ + "input ", + "is " + ], + [ + "u", + "tion" + ], + [ + "set", + ", " + ], + [ + "pro", + "vid" + ], + [ + "isContract", + "(" + ], + [ + "automa", + "tic " + ], + [ + "owned by `from`.\\n * - ", + "If the caller is not `from`, it " + ], + [ + "d", + "s" + ], + [ + "Interfac", + "e of the " + ], + [ + ";\\n\\n/**", + "\\n * @title " + ], + [ + "token/ERC20/", + "ERC20" + ], + [ + "And", + "Liquify" + ], + [ + "d", + "F" + ], + [ + "must ", + "fit into " + ], + [ + ", \\\"", + "SafeCast: value doesn't fit in " + ], + [ + "do", + "mainSeparator" + ], + [ + "other", + "wis" + ], + [ + "greater than ", + "largest " + ], + [ + "input ", + "must fit into " + ], + [ + "to a ", + "new " + ], + [ + "Y", + "MB" + ], + [ + "al ", + "representation" + ], + [ + "_isExcluded", + "MaxTransactionAmount" + ], + [ + "prec", + "isi" + ], + [ + "grant", + "ed to " + ], + [ + "YMB", + "OL" + ], + [ + ")", + ") {\\n " + ], + [ + "e", + "ar" + ], + [ + "Tr", + "ading" + ], + [ + "keccak256", + "(\\\"" + ], + [ + "token/ERC20/", + "IERC20" + ], + [ + "`", + "sender" + ], + [ + "\\n *", + "/\\n " + ], + [ + "Pay", + "ment" + ], + [ + "pric", + "e " + ], + [ + "t", + "TransferAmount" + ], + [ + "ow", + "er" + ], + [ + "owner", + ",\\n address " + ], + [ + "Re", + "vert" + ], + [ + "au", + "ge" + ], + [ + "B", + "l" + ], + [ + "from ", + "the zero address\\\");\\n require(" + ], + [ + "oft", + "wa" + ], + [ + "Ver", + "sion" + ], + [ + "2", + "C" + ], + [ + "en", + "/" + ], + [ + "token", + "1" + ], + [ + "option", + "al " + ], + [ + "s]", + ".\\n */\\n function _" + ], + [ + ";\\n ", + "// " + ], + [ + "ta", + "in " + ], + [ + "block", + "Number" + ], + [ + "\\n *\\n * ", + "_Available since v4." + ], + [ + "excludeFrom", + "Fees" + ], + [ + "Over", + "flow" + ], + [ + "a / ", + "result" + ], + [ + "`", + "newOwner" + ], + [ + "transfer", + " of " + ], + [ + "sy", + "stem" + ], + [ + "Val", + "ues" + ], + [ + "er", + "-" + ], + [ + "ro", + "ot " + ], + [ + "to ", + "the zero address\"" + ], + [ + "chang", + "e" + ], + [ + "Transfer(address indexed from, address indexed ", + "to, uint256 " + ], + [ + "A", + "f" + ], + [ + "de", + "posit" + ], + [ + "uint256", + ", " + ], + [ + "Non", + "existent" + ], + [ + "_holder", + "Last" + ], + [ + "to a new ", + "account (" + ], + [ + "(", + "\\n " + ], + [ + "ed", + "\"" + ], + [ + "ownership", + " of the contract " + ], + [ + "expect", + "ed " + ], + [ + "(sender", + ", recipient, amount" + ], + [ + "dif", + "fe" + ], + [ + " ", + ">= " + ], + [ + "v", + "en" + ], + [ + "pro", + "bl" + ], + [ + "16", + "0" + ], + [ + "cr", + "yp" + ], + [ + "s", + ". " + ], + [ + "ing ", + "of " + ], + [ + " = ", + "new " + ], + [ + "allowance ", + "granted to " + ], + [ + "\\n */\\n", + "contract " + ], + [ + "cer", + "tain " + ], + [ + "_holderLast", + "Transfer" + ], + [ + "on", + "ce " + ], + [ + "Ex", + "traData" + ], + [ + "for", + "\\n * " + ], + [ + "struct", + "Hash" + ], + [ + "`spender` ", + "by " + ], + [ + "To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hook", + "s].\\n */\\n function _" + ], + [ + "probl", + "ems " + ], + [ + "s", + "eri" + ], + [ + "Ad", + "dition" + ], + [ + "with ", + "an " + ], + [ + "tim", + "e " + ], + [ + "eration", + "s" + ], + [ + "OperatorFilte", + "rer" + ], + [ + "A", + "tom" + ], + [ + "}", + ". " + ], + [ + "th", + "row" + ], + [ + "ext", + "code" + ], + [ + "ve", + "al" + ], + [ + "gu", + "ide" + ], + [ + "Implementation", + " of the " + ], + [ + "ly", + "ing " + ], + [ + "_AD", + "MIN" + ], + [ + "buffer", + "[" + ], + [ + "move ", + "this " + ], + [ + "to a new account (", + "`newOwner" + ], + [ + "ownership of the contract ", + "to a new account (`newOwner" + ], + [ + "2", + " " + ], + [ + "M", + "ENT" + ], + [ + "to", + "Uint" + ], + [ + "can be used ", + "as a " + ], + [ + "_ENT", + "ERED" + ], + [ + ".", + "\\n function " + ], + [ + "\\n *", + " " + ], + [ + "wh", + "itelist" + ], + [ + "\\n */\\n ", + "function " + ], + [ + "ETHTo", + "Fee" + ], + [ + "R", + "el" + ], + [ + "al", + "is" + ], + [ + "lo", + "c" + ], + [ + "multipl", + "e " + ], + [ + "creases the ", + "allowance granted to " + ], + [ + ");", + "\\n " + ], + [ + "}\\n ", + "return " + ], + [ + "`spender` by ", + "the caller" + ], + [ + "ownership of the contract to a new account (`newOwner", + "`" + ], + [ + "es ", + "are " + ], + [ + "decimal", + "s " + ], + [ + "Returns a boolean value indicating whether the operation succeeded", + ".\\n *\\n * Emits a {Transfer} event.\\n */\\n function " + ], + [ + "}", + "\\n * " + ], + [ + "send", + "ETHToFee" + ], + [ + "lat", + "er " + ], + [ + "` must have ", + "a balance of at least `amount" + ], + [ + "abil", + "ity" + ], + [ + "alternative ", + "to " + ], + [ + "d", + "o " + ], + [ + "el", + "ock" + ], + [ + "Ro", + "ot" + ], + [ + "RecoverError", + "." + ], + [ + "(target, data", + ", \\\"Address: low-level " + ], + [ + "m", + "erkle" + ], + [ + "address ", + "private " + ], + [ + "{approve", + "} that " + ], + [ + "mitig", + "ation " + ], + [ + "is an ", + "alternative to " + ], + [ + "how", + "-" + ], + [ + "Atom", + "ically " + ], + [ + "can be used as a ", + "mitigation " + ], + [ + "creases the allowance granted to ", + "`spender` by the caller" + ], + [ + "{approve} that ", + "can be used as a mitigation " + ], + [ + "is an alternative to ", + "{approve} that can be used as a mitigation " + ], + [ + "(", + "which " + ], + [ + "B", + "atch" + ], + [ + "C", + "ach" + ], + [ + "S", + "ec" + ], + [ + "T", + " " + ], + [ + "T", + "ar" + ], + [ + "es", + ", " + ], + [ + "account", + " != address(0), \\\"ERC20: " + ], + [ + "Return", + " the " + ], + [ + "rent", + " " + ], + [ + "\\n ) external ", + "returns (" + ], + [ + "\"ERC20: approve ", + "to the zero address\"" + ], + [ + "granted ", + "`role" + ], + [ + "YMBOL", + "S" + ], + [ + "Nonexistent", + "Token" + ], + [ + "_holderLastTransfer", + "Timestamp" + ], + [ + "re", + "ction" + ], + [ + "ex", + "ample" + ], + [ + "ec", + "recover" + ], + [ + " for ", + "the " + ], + [ + "\"ERC20: approve ", + "from the zero address\"" + ], + [ + "arith", + "me" + ], + [ + "9", + "F" + ], + [ + "a", + "\\n * `" + ], + [ + "se", + "con" + ], + [ + "https://eips.ethereum.org/EIPS/eip-", + "165" + ], + [ + ".", + "\\n // " + ], + [ + "A", + "A" + ], + [ + "in", + "variant" + ], + [ + "el", + "ement" + ], + [ + " the ", + "token " + ], + [ + "tw", + "os" + ], + [ + "QueryFor", + "NonexistentToken" + ], + [ + "L", + "ea" + ], + [ + "tr", + "ack" + ], + [ + "ON", + "E_" + ], + [ + "a {", + "Role" + ], + [ + "me", + "an" + ], + [ + "and burning", + ".\\n *\\n * Calling conditions:\\n *\\n * - " + ], + [ + "`", + "nonReentrant" + ], + [ + "Max", + "Wallet" + ], + [ + "reg", + "iste" + ], + [ + "decre", + "ment" + ], + [ + "BBBB", + "BBBB" + ], + [ + ";\\n\\n // Mapping ", + "from " + ], + [ + "set to ", + "the zero address" + ], + [ + "problems ", + "described in " + ], + [ + ")", + ") private " + ], + [ + "nam", + "e = " + ], + [ + "Cop", + "y" + ], + [ + "S", + "al" + ], + [ + "ec", + "ess" + ], + [ + ") {", + "\\n " + ], + [ + "ul", + "ar " + ], + [ + "new", + "Num" + ], + [ + "_", + "statu" + ], + [ + "b", + "its " + ], + [ + ") private ", + "view returns (" + ], + [ + "burned", + ".\\n * - `" + ], + [ + "}\\n\\n ", + "function " + ], + [ + "Manag", + "er" + ], + [ + "n", + "et" + ], + [ + "p", + "at" + ], + [ + "r", + "TransferAmount" + ], + [ + "al", + "ong " + ], + [ + "Re", + "qu" + ], + [ + "a s", + "afe " + ], + [ + "Fl", + "ag" + ], + [ + "IZ", + "ED" + ], + [ + ";\\r\\n", + "\\r\\n" + ], + [ + "####", + "####" + ], + [ + "PL", + "Y" + ], + [ + "utils/introspection/", + "IERC165" + ], + [ + "address[] calldata ", + "path" + ], + [ + "+", + " (" + ], + [ + "v", + "ault" + ], + [ + "qu", + "eri" + ], + [ + "Transfer", + "To" + ], + [ + "point", + " " + ], + [ + "inter", + "action" + ], + [ + "revoke", + "Role" + ], + [ + "UP", + "PLY" + ], + [ + "owned by `from`.\\n * - If the caller is not `from`, it ", + "must be " + ], + [ + "n", + "c" + ], + [ + "ing", + "-" + ], + [ + "im", + "it " + ], + [ + "total", + "Tokens" + ], + [ + "cl", + "us" + ], + [ + "8", + "0" + ], + [ + "C", + "E" + ], + [ + "V", + "4" + ], + [ + "b", + "pt" + ], + [ + "Sel", + "ector" + ], + [ + "50", + "5" + ], + [ + "sour", + "ces" + ], + [ + "}", + "\"" + ], + [ + "es ", + "for " + ], + [ + "dis", + "play" + ], + [ + "required ", + "by the " + ], + [ + "on be", + "half " + ], + [ + "\"", + "abi" + ], + [ + "\"", + "Solidity" + ], + [ + "\"", + "setting" + ], + [ + "\"", + "output" + ], + [ + "\"", + "language" + ], + [ + "\"", + "sources" + ], + [ + "I", + "ERC" + ], + [ + "}", + "\\n }\\n\\n " + ], + [ + "th", + "ed" + ], + [ + "byt", + "ecode\"" + ], + [ + " = ", + "1" + ], + [ + ") {\\n ", + "if (" + ], + [ + "iz", + "ed " + ], + [ + "Sel", + "ection" + ], + [ + "read", + "thed" + ], + [ + "oc", + "s.io/" + ], + [ + "Byt", + "ecode\"" + ], + [ + "izer", + "\"" + ], + [ + "\"evm.", + "deployed" + ], + [ + "\"evm.", + "bytecode\"" + ], + [ + "\"abi", + "\"" + ], + [ + "\"Solidity", + "\"" + ], + [ + "\"setting", + "s\"" + ], + [ + "\"output", + "Selection" + ], + [ + "\"language", + "\"" + ], + [ + "\"sources", + "\"" + ], + [ + "readthed", + "ocs.io/" + ], + [ + "\"evm.deployed", + "Bytecode\"" + ], + [ + "\"outputSelection", + "\"" + ], + [ + "readthedocs.io/", + "en/" + ], + [ + " ", + "// " + ], + [ + "\"", + "optim" + ], + [ + "\"", + "run" + ], + [ + "\"", + "enabled\"" + ], + [ + "L", + "p" + ], + [ + "`", + ".\\n */\\n function _" + ], + [ + "value", + "s are " + ], + [ + "mo", + "re" + ], + [ + "TokenOwnership", + " " + ], + [ + "IERC721Receiver-onERC721Received}, which is called ", + "upon " + ], + [ + "a safe ", + "transfer" + ], + [ + "\"optim", + "izer\"" + ], + [ + "\"run", + "s\"" + ], + [ + "IERC721Receiver-onERC721Received}, which is called upon ", + "a safe transfer" + ], + [ + "by ", + "default" + ], + [ + "used ", + "for " + ], + [ + "11", + "55" + ], + [ + "al", + "ing " + ], + [ + "Ex", + "it" + ], + [ + "Enumerable", + "Set" + ], + [ + "reentr", + "anc" + ], + [ + "I", + "m" + ], + [ + "\\n ", + "if (" + ], + [ + "\\\"", + ");\\n }\\n\\n /**\\n * @dev " + ], + [ + "onlyOwner ", + "{\\n require(" + ], + [ + "URN", + "ED" + ], + [ + "(", + ") public " + ], + [ + " ", + " " + ], + [ + "buy", + "LiquidityFee" + ], + [ + "(uint256 a, uint256 b", + ") internal pure returns (uint256) {\\n " + ], + [ + "set._in", + "ner, " + ], + [ + "(", + "\\n " + ], + [ + "iz", + "ation" + ], + [ + "scal", + "ingFactor" + ], + [ + "_exists", + "(tokenId" + ], + [ + "'", + " " + ], + [ + "h", + "el" + ], + [ + "account", + "Balance " + ], + [ + "transfer", + "Delay" + ], + [ + "success", + "ful" + ], + [ + "sto", + "re" + ], + [ + "app", + "li" + ], + [ + "Ext", + "ension" + ], + [ + "s", + "ent" + ], + [ + "token", + "0" + ], + [ + "Owner", + "(" + ], + [ + ".\\n *\\n * ", + "See {" + ], + [ + "ETH", + "For" + ], + [ + "_allowances", + "[" + ], + [ + ") internal view returns (", + "bool" + ], + [ + "addition", + "al " + ], + [ + "https://github.com/", + "ethereum" + ], + [ + "S", + "lot " + ], + [ + " ", + " " + ], + [ + ";\\n ", + "if (" + ], + [ + "ETH", + " " + ], + [ + "src", + "Rep" + ], + [ + "ful", + "l" + ], + [ + "9", + "0" + ], + [ + "sh", + "r" + ], + [ + "IERC165", + " {\\n /**\\n * @dev " + ], + [ + "collection", + " " + ], + [ + "caller is not the owner", + "\"" + ], + [ + ")", + "\"" + ], + [ + "vi", + "a {" + ], + [ + "transfer", + "}" + ], + [ + "numb", + "er " + ], + [ + "Pool", + " " + ], + [ + "Auth", + "or" + ], + [ + "divis", + "or " + ], + [ + "l", + "aun" + ], + [ + ")\\n ", + "public" + ], + [ + "AP", + "I" + ], + [ + "utils/introspection/", + "ERC165" + ], + [ + ")", + "\\n // " + ], + [ + ".", + "call{" + ], + [ + "w", + "ould " + ], + [ + "bl", + "acklist" + ], + [ + "lock", + "The" + ], + [ + "lockThe", + "Swap" + ], + [ + "d", + "ed" + ], + [ + "e ", + "it " + ], + [ + "at", + "e the " + ], + [ + ", _", + "data" + ], + [ + "l", + "ab" + ], + [ + "th", + "at" + ], + [ + "\\n\\n", + "// " + ], + [ + ", uint256 ", + "index" + ], + [ + "3333", + "3333" + ], + [ + "\"Ownable: ", + "caller is not the owner\"" + ], + [ + "A", + "G" + ], + [ + "function ", + "to " + ], + [ + "call", + "ed" + ], + [ + "eth", + "_" + ], + [ + "Mem", + "ber" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Transfers ", + "ownership of the contract to a new account (`newOwner`" + ], + [ + "clus", + "i" + ], + [ + " ", + "{" + ], + [ + "l", + "ect" + ], + [ + "}", + "\\n }\\n}\\n\"" + ], + [ + "For ", + "example" + ], + [ + "u", + "ce " + ], + [ + "contract", + "s-" + ], + [ + "msg.sender", + " == " + ], + [ + "own", + "ed " + ], + [ + "BITMASK", + "_ADDRESS" + ], + [ + "` operator.\\n *\\n * Requirements:\\n *\\n * - ", + "input must fit into " + ], + [ + "reverting on\\n * overflow (when the ", + "input is " + ], + [ + "isContract(", + "target" + ], + [ + " ", + "L" + ], + [ + "m", + "etadata " + ], + [ + "tr", + "a " + ], + [ + "), \\\"", + "Address: " + ], + [ + ";\\r\\n }\\r\\n", + "\\r\\n function " + ], + [ + "isContract(target", + "), \\\"Address: " + ], + [ + "F", + "E" + ], + [ + "J", + "oin" + ], + [ + "n", + "ecess" + ], + [ + ".s", + "afe" + ], + [ + "lea", + "ves " + ], + [ + ") public view virtual override returns (", + "uint256) {\\n return " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`", + ").\\n * " + ], + [ + "7", + "39" + ], + [ + "w", + "allet " + ], + [ + "ERC721", + "." + ], + [ + "operator", + " " + ], + [ + ".\\n *\\n * _Available since ", + "v4." + ], + [ + "zero.\\n *\\n * ", + "To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _" + ], + [ + "Contract ", + "modul" + ], + [ + " ", + "F" + ], + [ + "_", + "un" + ], + [ + "ou", + "gh " + ], + [ + ",\\n address to", + ",\\n " + ], + [ + "super", + "._" + ], + [ + "Us", + "er" + ], + [ + "owner", + " of the " + ], + [ + "mo", + "ved " + ], + [ + "}\\n", + "}\\n\"" + ], + [ + ") public virtual ", + "returns (bool) {\\n " + ], + [ + ");\\n return true", + ";\\n }\\n\\n /**\\n * @dev " + ], + [ + "norm", + "al" + ], + [ + "D", + "own" + ], + [ + "wa", + "nt" + ], + [ + "IERC721", + "A" + ], + [ + "asset", + "s" + ], + [ + "fallback", + " " + ], + [ + "eas", + "i" + ], + [ + "E", + "V" + ], + [ + "P", + "P" + ], + [ + "re", + "alis" + ], + [ + "es", + "." + ], + [ + "in ", + "packed " + ], + [ + "_tax", + "Fee" + ], + [ + "Add", + "r" + ], + [ + "a contract", + ".\\n *\\n * " + ], + [ + "mapping ", + "(address => " + ], + [ + "b", + "ene" + ], + [ + "re", + "ak" + ], + [ + "))", + "\\n " + ], + [ + "remo", + "ve " + ], + [ + "DEFAULT", + "_ADMIN" + ], + [ + "g", + "g" + ], + [ + "i", + "ction" + ], + [ + "_owner", + " = " + ], + [ + "Returns ", + "an " + ], + [ + "KKKK", + "KKKK" + ], + [ + "amount exceeds allowance", + "\"" + ], + [ + "for (uint256 i = 0; i", + " < " + ], + [ + "3", + ".0" + ], + [ + ") public virtual override ", + "{\\n " + ], + [ + "address(this).", + "balance " + ], + [ + "A", + "pp" + ], + [ + "d", + "a" + ], + [ + "or", + "der " + ], + [ + "\\\"", + ":" + ], + [ + "mo", + "st " + ], + [ + "Pro", + "vides " + ], + [ + "), \\\"", + "ERC721: " + ], + [ + "such ", + "a " + ], + [ + "query ", + "for " + ], + [ + ":", + "\\n *" + ], + [ + " of ", + "`" + ], + [ + "round", + "ing" + ], + [ + "& ", + "0x" + ], + [ + "issu", + "es/" + ], + [ + "DEFAULT_ADMIN", + "_ROLE" + ], + [ + "Y", + " " + ], + [ + "[", + "_" + ], + [ + "b", + "r" + ], + [ + "ad", + "ing " + ], + [ + "ro", + "ll" + ], + [ + " = ", + "2" + ], + [ + "LE", + "MENT" + ], + [ + "l", + "ist " + ], + [ + "▒", + "▒" + ], + [ + "token", + "Index" + ], + [ + "Val", + "id" + ], + [ + "gr", + "aph" + ], + [ + "s[", + "i]" + ], + [ + "multi", + "p" + ], + [ + "` is zero, ", + "`tokenId` " + ], + [ + "(", + "owner" + ], + [ + "ed", + ". " + ], + [ + "cont", + "ext" + ], + [ + ";\\n ", + "_" + ], + [ + "OperatorF", + "ilter" + ], + [ + "m", + "ask" + ], + [ + "en", + "al" + ], + [ + "ifi", + "ed" + ], + [ + "De", + "posit" + ], + [ + "Royalty", + "Info" + ], + [ + "cryp", + "to" + ], + [ + "]", + ";\\n }\\n\\n /**\\n * @dev See {IERC20-" + ], + [ + "` ", + "as a " + ], + [ + "will ", + "be\\n * " + ], + [ + "ER_", + "ROLE" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Returns the ", + "downcasted " + ], + [ + "result = ", + "(" + ], + [ + "PL", + "-" + ], + [ + "Sec", + "ond" + ], + [ + "N", + "S" + ], + [ + "g", + "in" + ], + [ + " *", + "/" + ], + [ + "qu", + "e" + ], + [ + "Re", + "vert " + ], + [ + "account", + "s " + ], + [ + " = ", + "0x" + ], + [ + ".sol\\\";\\nimport \\\"", + "../" + ], + [ + "functionCallWithValue", + "(target, data" + ], + [ + "uint32", + " " + ], + [ + "bytes calldata ", + "data" + ], + [ + "m", + "eta" + ], + [ + "ing ", + "the\\n * " + ], + [ + "tw", + "o" + ], + [ + "_S", + "UPPLY" + ], + [ + "PER", + "MIT" + ], + [ + "multipl", + "ication " + ], + [ + "_tokenApproval", + "s[tokenId" + ], + [ + "extcode", + "size" + ], + [ + "0", + "1" + ], + [ + "D", + "OMAIN_SEPARATOR" + ], + [ + "0.", + "7" + ], + [ + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"", + "./" + ], + [ + "al representation", + ".\\n */\\n function " + ], + [ + "L", + "imits" + ], + [ + "ex", + "ist " + ], + [ + "`account", + "` " + ], + [ + "burned.\\n * - `", + "from` and `to` are never both " + ], + [ + "/", + "* " + ], + [ + "_", + "remove" + ], + [ + "ad", + "ecim" + ], + [ + "ate", + "g" + ], + [ + "cre", + "ator" + ], + [ + "and", + "\\n * " + ], + [ + "ass", + "ert" + ], + [ + "@openzeppelin", + "/" + ], + [ + "result ", + "+ " + ], + [ + "hex", + "adecim" + ], + [ + "a / result", + ") >> " + ], + [ + "result = (", + "result + " + ], + [ + "result = (result + ", + "a / result) >> " + ], + [ + "super.", + "supportsInterface(interfaceId" + ], + [ + ",", + "\\\"" + ], + [ + "a", + "25" + ], + [ + "b", + "4c" + ], + [ + ") external ", + "onlyOwner {\\n " + ], + [ + "Op", + "erations" + ], + [ + "more ", + "than " + ], + [ + "\"", + "@" + ], + [ + "re", + "t" + ], + [ + ": ", + "0" + ], + [ + "totalSupply", + "() external view returns (uint256" + ], + [ + "age ", + "of " + ], + [ + ");\\n return true", + ";\\n }\\n\\n /**\\n * @dev See {IERC20-" + ], + [ + "+", + " b" + ], + [ + "E", + "thereum" + ], + [ + "w", + "w" + ], + [ + "_in", + "ner" + ], + [ + "30", + "B" + ], + [ + "contain", + "s(" + ], + [ + "_approve(owner, ", + "spender, " + ], + [ + "f", + "ree " + ], + [ + "ch", + "ar" + ], + [ + "All", + " " + ], + [ + "ta", + "ken" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `", + "spender` cannot be the zero address" + ], + [ + "can be used ", + "to\\n * " + ], + [ + "can be used to\\n * ", + "e.g. " + ], + [ + "com", + "pu" + ], + [ + "\\n ", + "// " + ], + [ + "Qu", + "ant" + ], + [ + "_operator", + "Approval" + ], + [ + "rede", + "em" + ], + [ + ".\\n *\\n * Emits a {Transfer} event ", + "with " + ], + [ + "`", + ")" + ], + [ + "send", + "ing " + ], + [ + "88", + "D" + ], + [ + "total supply", + ".\\n *\\n * Emits a {Transfer} event with " + ], + [ + "Safe", + "ERC20" + ], + [ + "⠀⠀", + "⠀⠀" + ], + [ + "cannot ", + "overflow" + ], + [ + "INITIAL", + "IZED" + ], + [ + "name of the ", + "token" + ], + [ + ") ", + "<= " + ], + [ + "Co", + "de" + ], + [ + "private ", + "constant _" + ], + [ + "star", + "ting " + ], + [ + "24", + "88D" + ], + [ + "_S", + "YMBOLS" + ], + [ + "Ac", + "b4c" + ], + [ + "39", + "739" + ], + [ + "56", + "30B" + ], + [ + "4c", + "F5" + ], + [ + "65", + "9F" + ], + [ + "5d", + "Acb4c" + ], + [ + "0d", + "5630B" + ], + [ + "dF", + "2C" + ], + [ + "a25", + "0d5630B" + ], + [ + "39739", + "dF2C" + ], + [ + "4cF5", + "39739dF2C" + ], + [ + "659F", + "2488D" + ], + [ + "5dAcb4c", + "659F2488D" + ], + [ + "a250d5630B", + "4cF539739dF2C" + ], + [ + "a250d5630B4cF539739dF2C", + "5dAcb4c659F2488D" + ], + [ + "9", + "a" + ], + [ + "to", + "o " + ], + [ + "po", + "st" + ], + [ + ");\\n }\\n\\n /**\\n * @dev ", + "Destroy" + ], + [ + "ed to ", + "a " + ], + [ + "uint16", + " " + ], + [ + "(uint256 a, uint256 b) internal pure returns (", + "uint256) {\\n return " + ], + [ + "v2", + "-" + ], + [ + "specifi", + "ed " + ], + [ + "/", + "2" + ], + [ + "e", + "res" + ], + [ + "s ", + "in " + ], + [ + "un", + "der" + ], + [ + "erf", + "low" + ], + [ + " <", + "< " + ], + [ + "S", + " " + ], + [ + " ", + " " + ], + [ + "symbol", + " of the token" + ], + [ + ".\\n *\\n * This ", + "is an alternative to {approve} that can be used as a mitigation " + ], + [ + "(\\n address target,\\n bytes memory data", + ",\\n string memory errorMessage\\n " + ], + [ + "creases the allowance granted to `spender` by the caller", + ".\\n *\\n * This is an alternative to {approve} that can be used as a mitigation " + ], + [ + "problems described in ", + "{IERC20-approve}" + ], + [ + "creases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation ", + "for\\n * " + ], + [ + "ing ", + "for " + ], + [ + "Sta", + "k" + ], + [ + "mstore", + "(0x" + ], + [ + "glob", + "al" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address", + ".\\n */\\n function " + ], + [ + "(", + "hash" + ], + [ + ",", + "\\n " + ], + [ + "ed", + "Hash" + ], + [ + "`, ", + "which " + ], + [ + "Emitted ", + "when the " + ], + [ + "Fun", + "gi" + ], + [ + "(x", + ", " + ], + [ + "problems described in {IERC20-approve}", + ".\\n *\\n * Emits an {Approval} event indicating the updated allowance" + ], + [ + "creases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * ", + "problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance" + ], + [ + ")", + ") " + ], + [ + "T", + "reasury" + ], + [ + "un", + "der " + ], + [ + ") ", + "return (" + ], + [ + "if", + "(" + ], + [ + "sender", + " (" + ], + [ + "\\n\\npragma solidity ^", + "0.8." + ], + [ + "(from, to, ", + "amount" + ], + [ + "transferDelay", + "Enabled" + ], + [ + "(", + ") public view virtual returns (" + ], + [ + "h", + "ad" + ], + [ + "ed", + "Data" + ], + [ + "and ", + "not " + ], + [ + "be", + "ha" + ], + [ + "0, ", + "errorMessage" + ], + [ + "OR", + " " + ], + [ + "Hook that is called ", + "before " + ], + [ + "pat", + "tern" + ], + [ + "if ", + "`" + ], + [ + "Of", + "Owner" + ], + [ + "Tokens", + "SupportingFeeOnTransferTokens" + ], + [ + " b", + "its " + ], + [ + "delegat", + "ec" + ], + [ + "\\r\\n /**\\r\\n * @dev ", + "Returns the " + ], + [ + "utils/Context", + ".sol\\\";\\n\\n/**\\n * @dev " + ], + [ + "\\n view", + "\\n returns (" + ], + [ + "(address account, uint256 amount", + ") internal virtual {\\n require(" + ], + [ + "crypto", + "graph" + ], + [ + "&", + " _" + ], + [ + "r", + "ing " + ], + [ + "only", + "Allowed" + ], + [ + "any ", + "transfer of " + ], + [ + "Ro", + "yal" + ], + [ + ";\\n\\n ", + "emit Transfer" + ], + [ + "currentAllowanc", + "e = " + ], + [ + "Q", + "U" + ], + [ + "W", + "allet " + ], + [ + "[", + "tokenId" + ], + [ + "✓", + "✓" + ], + [ + "/**", + "\\n * " + ], + [ + ";\\n\\n", + " " + ], + [ + "this ", + "function" + ], + [ + ", \\\"", + "SafeMath: " + ], + [ + ") internal view returns (", + "bytes memory" + ], + [ + "mapping(address => ", + "bool" + ], + [ + "implement ", + "{" + ], + [ + "Col", + "lateral" + ], + [ + "token/ERC721/", + "extensions/" + ], + [ + "]", + ";\\n " + ], + [ + "c", + "ach" + ], + [ + "\\n // ", + "- " + ], + [ + ";\\n }\\n\\n ", + "/**\\n * @notice " + ], + [ + "p3", + ") internal view {\\n\\t\\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature(\\\"log(" + ], + [ + "If `to` refers to a smart contract, it must ", + "implement {" + ], + [ + "beha", + "vi" + ], + [ + "L", + "OT" + ], + [ + "n", + "ow" + ], + [ + "= ", + "2" + ], + [ + "contract", + "ETHBalance" + ], + [ + "this", + "\\n * function " + ], + [ + "tokens", + ". This include" + ], + [ + "set ", + "of " + ], + [ + "inter", + "medi" + ], + [ + "returndata_", + "size" + ], + [ + "(address account, uint256 amount) internal virtual {\\n require(", + "account != address(0), \\\"ERC20: " + ], + [ + "any transfer of ", + "tokens. This include" + ], + [ + ".", + "\\r" + ], + [ + "Licen", + "se " + ], + [ + "}.", + "\\n * " + ], + [ + ")\\\", p0, p1, p2, p3", + "));\\n\\t\\tignored;\\n\\t}\\n\\n\\tfunction " + ], + [ + "FFFFFFFF", + "FFFFFFFF" + ], + [ + "dst", + "Rep" + ], + [ + "restr", + "iction" + ], + [ + "Tar", + "get" + ], + [ + "Fee", + "Percentage" + ], + [ + "te", + "am" + ], + [ + "Error", + "s." + ], + [ + "Ethereum", + " " + ], + [ + "dat", + "as" + ], + [ + "length", + " " + ], + [ + "string memory ", + "name_" + ], + [ + "deleg", + "ator" + ], + [ + "ATION", + "S" + ], + [ + "ded", + "uc" + ], + [ + "NS", + "F" + ], + [ + "en", + "si" + ], + [ + "the ", + "actual " + ], + [ + "IERC721", + "Enumerable" + ], + [ + "Updat", + "e" + ], + [ + "}\\n ", + "}\\n " + ], + [ + "Enumer", + "ation" + ], + [ + "`", + "recipient" + ], + [ + "w", + "ell" + ], + [ + "it", + "e " + ], + [ + "red", + "uce " + ], + [ + "eth", + "er" + ], + [ + "Approved", + "OrOwner" + ], + [ + "Role(", + "role, account" + ], + [ + "EX", + "T_" + ], + [ + ".0) (", + "utils/" + ], + [ + "░░░░", + "░░░░" + ], + [ + "comput", + "edHash" + ], + [ + ".", + "readthedocs.io/en/" + ], + [ + "in", + "fin" + ], + [ + "un", + "d" + ], + [ + "role", + "]." + ], + [ + "Num", + "erator" + ], + [ + "solidity", + ".readthedocs.io/en/" + ], + [ + "(", + "int256 " + ], + [ + ")", + ");\\n " + ], + [ + "7", + "._\\n */\\n function " + ], + [ + "U", + "MB" + ], + [ + "v", + "ing " + ], + [ + "Appro", + "ve " + ], + [ + "with ", + "a " + ], + [ + "uint ", + "p1" + ], + [ + "p0, ", + "uint p1" + ], + [ + "-", + "supportsInterface" + ], + [ + "V", + "ault " + ], + [ + "_", + "liquidityFee" + ], + [ + "//", + "\\n // " + ], + [ + "a ", + "+ b" + ], + [ + "ur", + "ation" + ], + [ + "IERC165", + "-supportsInterface" + ], + [ + "uint64", + " " + ], + [ + "ext", + "ern" + ], + [ + "32", + ", " + ], + [ + "code", + ".length" + ], + [ + "bool ", + "public " + ], + [ + "(\\n address ", + "owner,\\n address " + ], + [ + "(\\r\\n ", + "address " + ], + [ + "be ", + "an " + ], + [ + " of ", + "{" + ], + [ + "this ", + "is " + ], + [ + "revert ", + "(" + ], + [ + "(data);\\n return ", + "verifyCallResult" + ], + [ + ";\\n", + "}\\n\"" + ], + [ + "pragma solidity ^", + "0.8." + ], + [ + "sell", + "MarketingFee" + ], + [ + "\"", + "dev" + ], + [ + "bu", + "il" + ], + [ + "Op", + "tional" + ], + [ + "https://", + "solidity.readthedocs.io/en/" + ], + [ + "will be ", + "the " + ], + [ + ", includ", + "ing " + ], + [ + ") internal returns (bytes memory) {\\n return ", + "functionCallWithValue(target, data" + ], + [ + "burned.\\n * - `from` and `to` are never both ", + "zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _" + ], + [ + "7", + "0" + ], + [ + "\\n * ", + "@return " + ], + [ + "red ", + "by " + ], + [ + "_msgSender(", + ") internal view virtual returns (" + ], + [ + "gener", + "ally " + ], + [ + "rati", + "o" + ], + [ + "precisi", + "on" + ], + [ + ");", + "\\n }" + ], + [ + "zero", + ".\\n */\\n function " + ], + [ + "Emits ", + "an {Approval" + ], + [ + "_symbol", + " = " + ], + [ + "incre", + "as" + ], + [ + ";\\n emit ", + "Approval" + ], + [ + "result = (result + a / result) >> ", + "1;\\n " + ], + [ + "W", + "rapp" + ], + [ + "s ", + "= _" + ], + [ + "un", + "safe " + ], + [ + "se", + "parator" + ], + [ + "at ", + "a " + ], + [ + "}.", + "\\n *\\n * " + ], + [ + "erk", + "le " + ], + [ + "auth", + "or " + ], + [ + "interfaces/", + "I" + ], + [ + "string private ", + "_name" + ], + [ + "set. O(1", + ").\\n *\\n * " + ], + [ + "approv", + "ed to " + ], + [ + "b", + "i" + ], + [ + "re", + "plac" + ], + [ + "all", + "oc" + ], + [ + "and ", + "be " + ], + [ + "decimals", + "} " + ], + [ + "BITPOS_N", + "UMB" + ], + [ + ".safe", + "Transfer" + ], + [ + "EXT_", + "INITIALIZED" + ], + [ + "BITPOS_NUMB", + "ER_" + ], + [ + "T", + "OKEN" + ], + [ + "[", + "i]" + ], + [ + "\\n ", + "require(" + ], + [ + "ic", + "k" + ], + [ + "0 ", + "? " + ], + [ + "sibl", + "e " + ], + [ + "address,", + "address," + ], + [ + "totalTokens", + "ToSwap" + ], + [ + ".", + "\\n // " + ], + [ + "anc", + "e " + ], + [ + "exp", + "ensi" + ], + [ + "\"ERC20: transfer ", + "amount exceeds allowance\"" + ], + [ + "7", + "6" + ], + [ + "account", + "s" + ], + [ + "token ", + "by either {approve} or {setApprovalForAll" + ], + [ + "code", + "Hash" + ], + [ + "current ", + "owner" + ], + [ + "Eth", + "er " + ], + [ + "It ", + "is " + ], + [ + "Typ", + "edData" + ], + [ + "information ", + "about " + ], + [ + "'", + "s\\n * " + ], + [ + "t ", + "= " + ], + [ + "rec", + "t " + ], + [ + "Address", + "Set" + ], + [ + "may ", + "not be " + ], + [ + "admin ", + "role" + ], + [ + "== 0) {\\n ", + "return " + ], + [ + "();\\n\\n /**\\n * ", + "The " + ], + [ + "-", + "like " + ], + [ + "}", + "\\n }\\n\\n function " + ], + [ + "to", + "Int" + ], + [ + "must ", + "exist " + ], + [ + ");\\n\\n ", + "/**\\n * @notice " + ], + [ + "\\r\\n *", + "\\r" + ], + [ + "`.\\n *\\n * ", + "This " + ], + [ + ".\\n */\\n event ", + "Transfer(address indexed from, address indexed to, uint256 " + ], + [ + "unchecked {", + "\\n // " + ], + [ + "call to non-contract", + "\\\");\\n\\n " + ], + [ + "must exist ", + "and be " + ], + [ + "(", + "success, returndata, errorMessage" + ], + [ + "I", + "ST" + ], + [ + "n", + "Checkpoint" + ], + [ + "}", + "\\n\\n /**\\n * @dev " + ], + [ + "the ", + "expected " + ], + [ + ";\\n\\n ", + "event " + ], + [ + "emit", + "ted " + ], + [ + "ed to ", + "be " + ], + [ + "s[", + "account" + ], + [ + "ed by ", + "`" + ], + [ + " != ", + "0" + ], + [ + ");\\r\\n", + "\\r\\n function " + ], + [ + ");\\n }\\n\\n ", + "// " + ], + [ + "signatu", + "res" + ], + [ + "E", + " " + ], + [ + "es", + "\"" + ], + [ + "ing ", + "`" + ], + [ + "override ", + "{\\n " + ], + [ + "_S", + "LOT" + ], + [ + "_balances[", + "from" + ], + [ + "Initializes the ", + "contract " + ], + [ + "-", + "f" + ], + [ + "H", + "EX" + ], + [ + ", ", + "uint amount" + ], + [ + "de", + "aling " + ], + [ + ".\\n *\\n * ", + "NOTE: " + ], + [ + "and", + "-" + ], + [ + "user", + "Data" + ], + [ + "reserve", + "1" + ], + [ + "dealing ", + "with " + ], + [ + ";", + "\\n function " + ], + [ + "ate", + ", " + ], + [ + "posi", + "tive " + ], + [ + "; i++", + ") {\\n " + ], + [ + "afely ", + "transfers " + ], + [ + "Optional", + "Return" + ], + [ + "D", + "en" + ], + [ + "c", + "lea" + ], + [ + "ed", + ")." + ], + [ + "address", + ", " + ], + [ + "can ", + "only be " + ], + [ + "when ", + "dealing with " + ], + [ + ",\\n uint256 ", + "amount\\n " + ], + [ + "they ", + "are " + ], + [ + "(address(this", + "), " + ], + [ + "afely transfers ", + "`tokenId` token from `from` to `to" + ], + [ + "l", + "et" + ], + [ + "when ", + "`to" + ], + [ + "should ", + "not be " + ], + [ + "string private ", + "_symbol" + ], + [ + "filte", + "red" + ], + [ + "` and `to` are both non-zero, ", + "`amount` " + ], + [ + "`nonReentrant", + "` " + ], + [ + "multiplication ", + "overflow" + ], + [ + "when `to", + "` is zero, `amount` " + ], + [ + "\"", + "user" + ], + [ + "(", + ") public view returns (" + ], + [ + "x", + " " + ], + [ + "call", + "y " + ], + [ + ".\\n */\\n event ", + "Approval(address indexed owner, address indexed " + ], + [ + "MAX", + "_" + ], + [ + "\"dev", + "doc\"" + ], + [ + "\"user", + "doc\"" + ], + [ + "call", + "OptionalReturn" + ], + [ + "li", + "ze" + ], + [ + "true", + ", " + ], + [ + "} event", + ".\\n *\\n * Requirements:\\n *\\n * - `" + ], + [ + "Not", + "Owner" + ], + [ + ");\\n }\\n\\n function ", + "_" + ], + [ + "Col", + "lection" + ], + [ + "B", + "as" + ], + [ + "E", + "T" + ], + [ + "owner", + "() " + ], + [ + "new", + "Amount" + ], + [ + "non", + "existent" + ], + [ + "block", + " " + ], + [ + "Un", + "iswap" + ], + [ + "55", + "55" + ], + [ + ".", + "mul(" + ], + [ + "I", + "AccessControl" + ], + [ + "P", + "ower" + ], + [ + "b", + ";\\n }\\n\\n /**\\n * @dev Returns the " + ], + [ + ", ", + "either " + ], + [ + "add(", + "32, " + ], + [ + ", uint ", + "p2" + ], + [ + "`tokenId` token", + ".\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist" + ], + [ + "when `from", + "` is zero, `amount` " + ], + [ + "when `from", + "` and `to` are both non-zero, `amount` " + ], + [ + "tx", + ".or" + ], + [ + "ally-", + "owned " + ], + [ + "set to the zero address", + ".\\n *\\n * Requirements:\\n *\\n * - `" + ], + [ + "divisor ", + "cannot be " + ], + [ + "extern", + "ally-owned " + ], + [ + "`tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist", + ".\\n */\\n function " + ], + [ + ")", + ");\\n }\\n\\n /**\\n * @dev " + ], + [ + "de", + "st" + ], + [ + "18", + "84" + ], + [ + "can be ", + "appli" + ], + [ + "number", + "Minted" + ], + [ + "umul", + "ative" + ], + [ + "))", + "\\n " + ], + [ + "chang", + "ing " + ], + [ + "chain", + "Id" + ], + [ + "an address ", + "where " + ], + [ + "_msgData", + "() internal view virtual returns (" + ], + [ + "an address where ", + "a contract " + ], + [ + ", ", + "they " + ], + [ + "ac", + "tive" + ], + [ + "ex", + "empt" + ], + [ + "vi", + "der" + ], + [ + ") {", + "\\r\\n " + ], + [ + "an ", + "externally-owned " + ], + [ + "check", + "s-" + ], + [ + "URI", + " for " + ], + [ + "balance ", + "for " + ], + [ + "vo", + "ting " + ], + [ + ".\\n *\\n * Emits a {Transfer", + "} event.\\n */\\n function _" + ], + [ + "s-", + "interaction" + ], + [ + "effect", + "s-interaction" + ], + [ + "checks-", + "effects-interaction" + ], + [ + "(", + "uint256(" + ], + [ + "re", + "vok" + ], + [ + "return", + "s " + ], + [ + "tokens", + "\\n * " + ], + [ + "].", + "sub(" + ], + [ + "uint96", + " " + ], + [ + ",\\n bytes memory ", + "_data" + ], + [ + "Quant", + "ity" + ], + [ + "2", + ",\\n " + ], + [ + "quantity", + "` " + ], + [ + "_in", + "it" + ], + [ + "perform", + " " + ], + [ + "minting ", + "and burning.\\n *\\n * Calling conditions:\\n *\\n * - " + ], + [ + "conc", + "ern" + ], + [ + "small", + "est " + ], + [ + ";", + "\\n }" + ], + [ + "s", + "qu" + ], + [ + "ERC721", + "Enumerable" + ], + [ + "ement", + " for " + ], + [ + "prod", + "1 " + ], + [ + "\\n /// ", + "@return " + ], + [ + " - ", + "denominator * " + ], + [ + ", string memory ", + "symbol_" + ], + [ + "; // ", + "inverse " + ], + [ + "get ", + "the " + ], + [ + "} else {", + "\\n " + ], + [ + "s\\n * ", + "minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - " + ], + [ + ");\\r\\n }\\r\\n", + "\\r\\n function " + ], + [ + "Lib", + "rar" + ], + [ + "exce", + "ed " + ], + [ + "PERMIT", + "_TYPEHASH" + ], + [ + "= 2", + " - denominator * " + ], + [ + "any transfer of tokens. This include", + "s\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - " + ], + [ + "string memory name_", + ", string memory symbol_" + ], + [ + "; // inverse ", + "mod " + ], + [ + "f", + "ar " + ], + [ + "n", + "ft" + ], + [ + "an", + "k" + ], + [ + ") {\\n ", + " " + ], + [ + "pragma solidity ^", + "0.8.0" + ], + [ + "diffe", + "rent " + ], + [ + "V", + "AL" + ], + [ + "f", + "ree" + ], + [ + " to be ", + "transferred" + ], + [ + "delegatec", + "all" + ], + [ + "If `to` refers to a smart contract, it must implement {", + "IERC721Receiver-onERC721Received}, which is called upon a safe transfer" + ], + [ + "datas", + "ize" + ], + [ + "m", + "it " + ], + [ + "de", + "si" + ], + [ + "um", + "ent" + ], + [ + "not", + "\\n * " + ], + [ + "\\u003", + "c" + ], + [ + "such ", + "as " + ], + [ + "MMMMMMMM", + "MMMMMMMM" + ], + [ + "_000", + "_000" + ], + [ + "execution ", + "context" + ], + [ + "R", + "en" + ], + [ + "_", + "setup" + ], + [ + "function", + "s to " + ], + [ + "is", + "zero" + ], + [ + "when ", + "`target` revert" + ], + [ + "address(this", + "), " + ], + [ + "these ", + "are " + ], + [ + "S", + "ION" + ], + [ + "amount", + "To" + ], + [ + ") {", + "\\n " + ], + [ + " is ", + "Context" + ], + [ + "``", + "owner" + ], + [ + "Wh", + "ile " + ], + [ + "x", + "x" + ], + [ + "\\\"", + " " + ], + [ + "sender", + "Balance" + ], + [ + "cor", + "rect " + ], + [ + "0x7", + "a250d5630B4cF539739dF2C5dAcb4c659F2488D" + ], + [ + "f", + "t " + ], + [ + "s", + "ti" + ], + [ + "ai", + "d " + ], + [ + "AT", + "UR" + ], + [ + "possibl", + "e" + ], + [ + ") internal view returns (", + "uint256) {\\n return " + ], + [ + "required ", + "for " + ], + [ + "revert reason ", + "when `target` revert" + ], + [ + "fallback ", + "revert reason when `target` revert" + ], + [ + "-", + "transaction" + ], + [ + "r", + "andom" + ], + [ + "ti", + "st" + ], + [ + "} ", + "interface" + ], + [ + "non", + "ce " + ], + [ + "meta", + "-transaction" + ], + [ + "IERC165-supportsInterface", + "}.\\n */\\n function " + ], + [ + "[", + "msg.sender" + ], + [ + "_", + "ownedTokens" + ], + [ + "si", + "de " + ], + [ + "approve", + "(address to, uint256 tokenId" + ], + [ + "oth", + "er than " + ], + [ + "in the ", + "EIP" + ], + [ + ";\\n }\\n ", + "return " + ], + [ + "Caller", + "NotOwner" + ], + [ + ");\\n return true;\\n }\\n\\n /**\\n * @dev ", + "Atomically " + ], + [ + "``owner", + "``'s " + ], + [ + "as ", + "`" + ], + [ + "value ", + "<= " + ], + [ + "errorMessage", + "` as a " + ], + [ + "errorMessage` as a ", + "fallback revert reason when `target` revert" + ], + [ + ")", + ".\\n */\\n function " + ], + [ + "c", + "our" + ], + [ + "exec", + "ut" + ], + [ + "0.6", + "." + ], + [ + "control", + " " + ], + [ + "name = ", + "name_" + ], + [ + "name of the token", + ".\\n */\\n function name" + ], + [ + "E", + "nt" + ], + [ + "N", + "or" + ], + [ + ",\\n ", + "bool " + ], + [ + "token ", + "collection " + ], + [ + "msg.sender", + " and " + ], + [ + ", \\\"Address: ", + "insufficient " + ], + [ + "Cur", + "rent" + ], + [ + "Throws ", + "if " + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token ", + "must exist and be " + ], + [ + "lab", + "s/" + ], + [ + "ret", + "val" + ], + [ + "Nor", + "Approved" + ], + [ + "T", + "ER" + ], + [ + "g", + "auge" + ], + [ + "ed ", + "(" + ], + [ + " of the ", + "transaction" + ], + [ + "V", + "3" + ], + [ + "_", + "b" + ], + [ + "balanceOf", + "(address owner" + ], + [ + ") private ", + "{\\n " + ], + [ + "dur", + "ing " + ], + [ + "OPER", + "ATIONS" + ], + [ + "Implementation of the ", + "{" + ], + [ + "RecoverError.", + "InvalidSignature" + ], + [ + "cryptograph", + "y/" + ], + [ + "CallerNotOwner", + "NorApproved" + ], + [ + "pro", + "pos" + ], + [ + "address(0), ", + "tokenId" + ], + [ + "exist", + "ence" + ], + [ + "mall", + "e" + ], + [ + "address) {\\n return ", + "msg.sender" + ], + [ + "information about ", + "the current " + ], + [ + "when `to` is zero, `amount` ", + "of ``from``'s " + ], + [ + "to ", + "!= address(0), \\\"" + ], + [ + ");\\n", + "\\n " + ], + [ + "sender", + " of the transaction" + ], + [ + "onlyOwner", + "(" + ], + [ + "With", + "Selector" + ], + [ + "_msgSender(", + "), \\\"" + ], + [ + " and ", + "its " + ], + [ + "As", + "set" + ], + [ + "contract is ", + "only " + ], + [ + "reduce ", + "the " + ], + [ + ",\\n bytes memory _data", + "\\n " + ], + [ + "-", + "26" + ], + [ + "pay", + "ing for " + ], + [ + "ed in ", + "such a " + ], + [ + "access", + "ed in such a " + ], + [ + "msg.data", + ", they " + ], + [ + "via ", + "msg.sender and " + ], + [ + "data. ", + "While " + ], + [ + "Provides ", + "information about the current " + ], + [ + "generally ", + "available" + ], + [ + "_symbol = ", + "symbol_" + ], + [ + "should not be ", + "accessed in such a " + ], + [ + "execution context", + ", including " + ], + [ + "these are ", + "generally available" + ], + [ + "sender of the transaction", + " and its " + ], + [ + "msg.data, they ", + "should not be accessed in such a " + ], + [ + "via msg.sender and ", + "msg.data, they should not be accessed in such a " + ], + [ + "data. While ", + "these are generally available" + ], + [ + "Provides information about the current ", + "execution context, including " + ], + [ + "sender of the transaction and its ", + "data. While these are generally available" + ], + [ + "via msg.sender and msg.data, they should not be accessed in such a ", + "direct" + ], + [ + "*", + "= 2 - denominator * " + ], + [ + "`", + "'s " + ], + [ + "function ", + "call" + ], + [ + "is ", + "concern" + ], + [ + "` ", + "from " + ], + [ + "Re", + "f" + ], + [ + "s the ", + "account " + ], + [ + "as ", + "far " + ], + [ + "value ", + "was " + ], + [ + "indexed ", + "tokenId" + ], + [ + "since ", + "when dealing with " + ], + [ + "man", + "ner, " + ], + [ + "library", + "-like " + ], + [ + "inverse ", + "*= 2 - denominator * " + ], + [ + "execution ", + "may not be " + ], + [ + "\\n * - ", + "an address where a contract " + ], + [ + "as an ", + "application" + ], + [ + "inverse", + "; // inverse mod " + ], + [ + "sender (", + "as far " + ], + [ + "intermedi", + "ate, " + ], + [ + "the actual ", + "sender (as far " + ], + [ + "required for ", + "intermediate, " + ], + [ + "meta-transaction", + "s the account " + ], + [ + "contract is only ", + "required for intermediate, " + ], + [ + "paying for ", + "execution may not be " + ], + [ + "is concern", + "ed)." + ], + [ + "manner, ", + "since when dealing with " + ], + [ + "library-like ", + "contracts." + ], + [ + "inverse *= 2 - denominator * ", + "inverse; // inverse mod " + ], + [ + "the actual sender (as far ", + "as an application" + ], + [ + "meta-transactions the account ", + "sending " + ], + [ + "contract is only required for intermediate, ", + "library-like contracts." + ], + [ + "paying for execution may not be ", + "the actual sender (as far as an application" + ], + [ + "\"", + "ERC721: " + ], + [ + "_", + "fee" + ], + [ + "i", + "/" + ], + [ + "out ", + "of " + ], + [ + ".\\n *\\n * _Available since v3.1._\\n */\\n function ", + "functionCall" + ], + [ + ".\\n *\\n * _Available since v3.1._\\n */\\n function ", + "functionCallWithValue" + ], + [ + "again", + "st " + ], + [ + "nonexistent", + " token" + ], + [ + "M", + "ust " + ], + [ + "N", + "o" + ], + [ + "c", + "i" + ], + [ + "n", + "eg" + ], + [ + "t", + "est" + ], + [ + "\\n ", + "virtual" + ], + [ + "Max", + " " + ], + [ + "number", + "s" + ], + [ + "(uint256 tokenId", + ") public view virtual override returns (" + ], + [ + ", bool ", + "approved" + ], + [ + "approval", + " is " + ], + [ + "when `from` and `to` are both non-zero, `amount` ", + "of ``from``'s " + ], + [ + ".\\n *\\n * ", + "The " + ], + [ + "in ", + "existence" + ], + [ + "for", + "ward" + ], + [ + "revert", + "(\\\"" + ], + [ + "_S", + "T" + ], + [ + "_", + "allowed" + ], + [ + "e", + "\\n * " + ], + [ + "\\\"", + ";\\n " + ], + [ + "\\r", + "\\n " + ], + [ + "ch", + "il" + ], + [ + "sh", + "ort" + ], + [ + "`account", + "` is " + ], + [ + "\\n *", + " " + ], + [ + "errorMessage` as a fallback revert reason when `target` revert", + "s" + ], + [ + "in", + "\\n * " + ], + [ + "ve", + "s the " + ], + [ + "ab", + "s" + ], + [ + "0 ", + "if " + ], + [ + "OwnershipTransferred", + "(" + ], + [ + "Round", + "ing " + ], + [ + "cop", + "y " + ], + [ + "(account, address(0), ", + "amount);\\n\\n " + ], + [ + ",\\n address to,\\n ", + "uint deadline" + ], + [ + "onlyAllowed", + "Operator" + ], + [ + "(\\n address owner,\\n address ", + "spender" + ], + [ + "\"", + "librari" + ], + [ + "b", + "er " + ], + [ + "mapping(address => uint256", + ") private " + ], + [ + "isExcluded", + "From" + ], + [ + "approved to ", + "move this " + ], + [ + "i", + "on" + ], + [ + "pay", + "load" + ], + [ + "IUniswapV2", + "Pair" + ], + [ + "opcode ", + "to " + ], + [ + "(address(0), account, amount", + ");\\n\\n " + ], + [ + "ensu", + "re" + ], + [ + ") internal returns (bytes memory) {\\n return functionCallWithValue(target, data", + ", " + ], + [ + "\"librari", + "es\"" + ], + [ + "-", + "name" + ], + [ + "U", + "ri" + ], + [ + "u", + "s " + ], + [ + "x", + "y " + ], + [ + "\\n ", + "*" + ], + [ + "ou", + "ched" + ], + [ + "ic", + "it" + ], + [ + "new", + "Implementation" + ], + [ + "0x", + "dead" + ], + [ + "do", + "main " + ], + [ + "chang", + "ed " + ], + [ + "gas ", + "unt" + ], + [ + "{\\r\\n ", + "require(" + ], + [ + "remaining ", + "gas unt" + ], + [ + "opcode ", + "(which " + ], + [ + "Context ", + "{\\n function " + ], + [ + "leaves ", + "remaining gas unt" + ], + [ + "PL-", + "3.0" + ], + [ + "ouched", + ") " + ], + [ + "opcode (which ", + "leaves remaining gas unt" + ], + [ + "opcode (which leaves remaining gas unt", + "ouched) " + ], + [ + "1", + ";\\n " + ], + [ + "9", + "2" + ], + [ + ") ", + "- 1" + ], + [ + "buffer", + " = new " + ], + [ + "Implement", + "er" + ], + [ + "() external ", + "pure returns (" + ], + [ + "invalid ", + "opcode to " + ], + [ + "remaining ", + "gas" + ], + [ + "consum", + "ing all " + ], + [ + "revert (", + "consuming all " + ], + [ + "tx.or", + "igin" + ], + [ + "opcode (which leaves remaining gas untouched) ", + "while " + ], + [ + "invalid opcode to ", + "revert (consuming all " + ], + [ + "invalid opcode to revert (consuming all ", + "remaining gas" + ], + [ + "b", + "it" + ], + [ + "e", + "p" + ], + [ + "e", + "em" + ], + [ + "|", + " " + ], + [ + "ERC20", + "Permit" + ], + [ + " * ", + "length" + ], + [ + "Res", + "erve" + ], + [ + "upp", + "er " + ], + [ + "behavi", + "or " + ], + [ + "Context {\\n function ", + "_msgSender() internal view virtual returns (" + ], + [ + "E", + "dition" + ], + [ + "token", + "." + ], + [ + "\\n * ", + "https://" + ], + [ + ");\\n\\n ", + "if (" + ], + [ + "implement", + "er" + ], + [ + "ON", + "E" + ], + [ + "En", + "abl" + ], + [ + "revert reas", + "on" + ], + [ + "\"Address: ", + "low-level " + ], + [ + ". The ", + "result is " + ], + [ + "transferred to `to`.\\n * - ", + "when `from` is zero, `amount` " + ], + [ + "a", + "ver" + ], + [ + "dex", + "Router" + ], + [ + "In", + "f" + ], + [ + "new", + "Wallet" + ], + [ + "See {", + "IERC20-" + ], + [ + ");\\n\\n /**\\n * @dev Returns the ", + "amount of tokens " + ], + [ + "IERC165-supportsInterface}.\\n */\\n function ", + "supportsInterface(bytes4 interfaceId) public view virtual " + ], + [ + "N", + "G" + ], + [ + "o", + "se " + ], + [ + "s", + "\\n " + ], + [ + ". ", + "We " + ], + [ + "19", + "2" + ], + [ + "Do", + "es not " + ], + [ + ", r", + ", s" + ], + [ + "manage ", + "all" + ], + [ + "al", + "way" + ], + [ + "se", + "ction" + ], + [ + "tokens ", + "of " + ], + [ + "can be ", + "used to " + ], + [ + "start", + "TokenId " + ], + [ + "owner, ", + "spender" + ], + [ + "amountToken", + "Desired" + ], + [ + "whenNot", + "Paused" + ], + [ + "address owner = _msgSender(", + ");\\n " + ], + [ + "} interface", + ".\\n *\\n * " + ], + [ + "6", + "8" + ], + [ + "l", + "n" + ], + [ + "ent", + " " + ], + [ + "as", + "sign" + ], + [ + "override", + "(" + ], + [ + ";\\n }\\n\\n function ", + "_msgData() internal view virtual returns (" + ], + [ + "at", + "(" + ], + [ + "it ", + "to " + ], + [ + "pro", + "t" + ], + [ + "bytes ", + "calldata" + ], + [ + "lat", + "est" + ], + [ + "Fe", + "e = " + ], + [ + "allowance(", + "owner, spender" + ], + [ + "Requ", + "est" + ], + [ + "C", + "le" + ], + [ + "D", + "ecim" + ], + [ + "_", + "rol" + ], + [ + "\\n ", + "return " + ], + [ + "Token", + "URI" + ], + [ + "ll", + " " + ], + [ + "\\n * ", + "via msg.sender and msg.data, they should not be accessed in such a direct" + ], + [ + "the call", + "ing " + ], + [ + "Lo", + "ok" + ], + [ + "dis", + "cour" + ], + [ + ".\\n */\\n", + "library " + ], + [ + "the\\n * ", + "sender of the transaction and its data. While these are generally available" + ], + [ + "Provides information about the current execution context, including ", + "the\\n * sender of the transaction and its data. While these are generally available" + ], + [ + "\\n * via msg.sender and msg.data, they should not be accessed in such a direct", + "\\n * " + ], + [ + "discour", + "ag" + ], + [ + "Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available", + "\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * " + ], + [ + "1", + ")" + ], + [ + "2", + ", " + ], + [ + "V", + "R" + ], + [ + "is", + "ting " + ], + [ + "call", + "er" + ], + [ + "\\n * ", + "is concerned)." + ], + [ + "token ", + "id" + ], + [ + "can ", + "call " + ], + [ + "chang", + "es " + ], + [ + ");\\n }\\n\\n ", + "/**" + ], + [ + "_red", + "isFee" + ], + [ + "call.\\n *\\n * _Available since v3.", + "3._\\n */\\n function " + ], + [ + "\\n *\\n * This ", + "contract is only required for intermediate, library-like contracts." + ], + [ + "GNU General Public ", + "License " + ], + [ + "and\\n * ", + "paying for execution may not be the actual sender (as far as an application" + ], + [ + "meta-transactions the account sending ", + "and\\n * paying for execution may not be the actual sender (as far as an application" + ], + [ + "Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * ", + "manner, since when dealing with " + ], + [ + "\\n * is concerned).", + "\\n *\\n * This contract is only required for intermediate, library-like contracts." + ], + [ + "meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application", + "\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts." + ], + [ + "edition", + "Id" + ], + [ + ".", + "sub(" + ], + [ + ", ", + "which is " + ], + [ + "ver", + "sion " + ], + [ + "that ", + "the " + ], + [ + "be", + "are" + ], + [ + "IERC20", + " token" + ], + [ + "Requirements:", + "\\r\\n *\\r" + ], + [ + "static ", + "call.\\n *\\n * _Available since v3.3._\\n */\\n function " + ], + [ + "-}[`functionCall`],\\n * but performing a ", + "static call.\\n *\\n * _Available since v3.3._\\n */\\n function " + ], + [ + "positive ", + "value" + ], + [ + "value <= ", + "type(" + ], + [ + "-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function ", + "functionStaticCall" + ], + [ + "function", + "al" + ], + [ + " = ", + "(" + ], + [ + "for ", + "an " + ], + [ + "`.", + "\\n " + ], + [ + "`, ", + "emits " + ], + [ + "denominator", + " " + ], + [ + "there ", + "are " + ], + [ + "query for ", + "nonexistent token" + ], + [ + "`, emits ", + "a {Role" + ], + [ + "un", + "iswap" + ], + [ + "` ", + "with " + ], + [ + "ms", + "b" + ], + [ + "di", + "rection" + ], + [ + ", uint256 ", + "_" + ], + [ + "0 ", + "and " + ], + [ + "C", + "alcul" + ], + [ + "D", + "istribu" + ], + [ + "r", + ",\\n bytes32 " + ], + [ + "updat", + "e the " + ], + [ + "false", + ", 0" + ], + [ + ",\\n bytes32 ", + "r,\\n bytes32 " + ], + [ + "fals", + "e " + ], + [ + "1", + "._" + ], + [ + "s ", + "{\\n " + ], + [ + "` ", + "will " + ], + [ + "log", + " in " + ], + [ + "pragma solidity ", + "0.8." + ], + [ + "Returns ", + "0 if " + ], + [ + "reg", + "ular " + ], + [ + "Counter", + "s" + ], + [ + "posi", + "tion " + ], + [ + "ERC721Receiver", + " " + ], + [ + "Converts a `uint256` to its ASCII `string` ", + "hexadecim" + ], + [ + "Return the ", + "log in " + ], + [ + "meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.", + "\\n */\\nabstract contract " + ], + [ + "Returns 0 if ", + "given " + ], + [ + "Return the log in ", + "base " + ], + [ + ";", + "\\r\\n " + ], + [ + "G", + "IST" + ], + [ + "P", + "tr" + ], + [ + "mint", + "ing" + ], + [ + "ect", + "ed " + ], + [ + "recei", + "ve " + ], + [ + "RE", + "GIST" + ], + [ + ", ", + "of a " + ], + [ + "pro", + "vide" + ], + [ + "from ", + "the caller" + ], + [ + "value ", + "= " + ], + [ + "_approve", + "(_msgSender(), " + ], + [ + ".\\n * ", + "The " + ], + [ + "metho", + "d" + ], + [ + "EE", + "EE" + ], + [ + ").max", + ", \\\"SafeCast: value doesn't fit in " + ], + [ + "program", + " is " + ], + [ + "e", + "q" + ], + [ + "an ", + "allowance " + ], + [ + "set", + "Fee" + ], + [ + "cre", + "ate " + ], + [ + "operator", + ", " + ], + [ + "] ", + "+ " + ], + [ + ";\\n }\\n\\n /**\\n * @dev See {", + "IERC721-" + ], + [ + "trading", + "Active" + ], + [ + "Red", + "eem" + ], + [ + ".call{", + "value: " + ], + [ + "OPERATIONS", + "\\n // =============================================================\\n\\n /**\\n * @dev " + ], + [ + ", of a ", + "positive value" + ], + [ + "H", + "el" + ], + [ + "25", + "5" + ], + [ + "red ", + "when the " + ], + [ + "mis", + "s" + ], + [ + "\\\":", + "\\\"" + ], + [ + "set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `", + "account" + ], + [ + " ", + "bytes " + ], + [ + "b", + "atch" + ], + [ + "====", + "\\n * " + ], + [ + "` ", + "(`" + ], + [ + "bool", + ", " + ], + [ + "rec", + "on" + ], + [ + ";\\n", + "\\n // " + ], + [ + "setApprovalForAll", + "(address operator" + ], + [ + "delet", + "e" + ], + [ + "]\\n * ", + "====\\n * " + ], + [ + "\"", + "lib/" + ], + [ + "-", + "string" + ], + [ + "9", + "5" + ], + [ + "r", + "Supply" + ], + [ + ");\\n", + "\\n // " + ], + [ + "This ", + "program is " + ], + [ + "Po", + "s" + ], + [ + "om", + "e " + ], + [ + "Revok", + "ed" + ], + [ + "owned by `from`.\\n * - If the caller is not `from`, it must be ", + "approved to move this " + ], + [ + "full", + " " + ], + [ + "result = (result + a / result) >> 1;\\n ", + "result = (result + a / result) >> 1;\\n " + ], + [ + "se", + "par" + ], + [ + "`, ", + "and " + ], + [ + "fee", + "To" + ], + [ + "filte", + "red " + ], + [ + "issue", + "s " + ], + [ + ", v", + ", r, s" + ], + [ + "I", + "V" + ], + [ + "address(this", + ")" + ], + [ + "fir", + "st" + ], + [ + "Chang", + "e" + ], + [ + ") return (", + "false, 0" + ], + [ + "=", + "lib/" + ], + [ + "th", + "er " + ], + [ + "allow", + "ed " + ], + [ + "Not", + "e: " + ], + [ + "minted for `to`.\\n * - ", + "when `to` is zero, `amount` of ``from``'s " + ], + [ + "when `from` and `to` are both non-zero, `amount` of ``from``'s ", + "tokens\\n * " + ], + [ + "`", + "`from``'s " + ], + [ + "at", + "ch " + ], + [ + "Token", + "Index" + ], + [ + "from ", + "`" + ], + [ + "Appro", + "ve" + ], + [ + "remo", + "ved " + ], + [ + "the owner", + " " + ], + [ + "2,\\n ", + "2,\\n " + ], + [ + "any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - ", + "when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * " + ], + [ + "domain ", + "separator" + ], + [ + "bl", + "ob" + ], + [ + "com", + "pl" + ], + [ + "`account", + "`.\\n */\\n function " + ], + [ + "approved ", + "operator" + ], + [ + "gh", + "t " + ], + [ + "REGIST", + "RY" + ], + [ + "1", + "96" + ], + [ + "T", + "rac" + ], + [ + "Paus", + "ed(" + ], + [ + "uint16", + " _" + ], + [ + "vari", + "abl" + ], + [ + ";\\n\\n // The ", + "bit " + ], + [ + "_EX", + "TRA" + ], + [ + "name = name_", + ";\\n " + ], + [ + "S", + "end" + ], + [ + "`", + "\\n * " + ], + [ + "total", + "Supply " + ], + [ + "implement", + "s the " + ], + [ + "_t", + "Owned" + ], + [ + "╬╬", + "╬╬" + ], + [ + "able is ", + "Context " + ], + [ + "Ren", + "oun" + ], + [ + "blob", + "/" + ], + [ + ";\\n\\n ", + "uint256 private " + ], + [ + " b", + "it " + ], + [ + "Admin", + "Role" + ], + [ + ", 0x", + "20" + ], + [ + "mload(", + "add(" + ], + [ + "prevOwnership", + "Packed" + ], + [ + "meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ", + "Context {\\n function _msgSender() internal view virtual returns (" + ], + [ + ".", + "code.length" + ], + [ + "3", + "\\\\x8" + ], + [ + "n", + "or " + ], + [ + "amount", + ");\\n " + ], + [ + "address ", + "that " + ], + [ + "tokens ", + "have been " + ], + [ + "Orac", + "le" + ], + [ + "\\\\xe", + "3\\\\x8" + ], + [ + "can be appli", + "ed to " + ], + [ + "C", + "reat" + ], + [ + "p", + "op" + ], + [ + ");", + "\\n\\n " + ], + [ + "using ", + "{" + ], + [ + "gener", + "ic " + ], + [ + "[EIP", + " " + ], + [ + "@openzeppelin/", + "contracts-" + ], + [ + "clea", + "red when the " + ], + [ + "approval is ", + "cleared when the " + ], + [ + "approval is cleared when the ", + "token is " + ], + [ + "\\n ", + "assembly {\\n " + ], + [ + "balanc", + "er-" + ], + [ + "desi", + "red " + ], + [ + "D", + "A" + ], + [ + "s", + "er" + ], + [ + "\\n", + "\\n // " + ], + [ + "s ", + "from " + ], + [ + "\\\"", + ");\\n " + ], + [ + "check", + "ing " + ], + [ + "(\\n ", + "bytes32 " + ], + [ + ") external", + ";\\n function " + ], + [ + "`account", + "`.\\n *\\n * " + ], + [ + "revert(", + "add(32, " + ], + [ + "Ar", + "ray" + ], + [ + "\\n *\\n * _Available since v4.", + "7._\\n */\\n function " + ], + [ + "_EXTRA", + "_DATA" + ], + [ + ",", + "\\n " + ], + [ + "n", + "on " + ], + [ + "token", + "Balance" + ], + [ + "no", + "s" + ], + [ + "spender", + ", uint256 value" + ], + [ + ");\\n", + "error " + ], + [ + "bytes32", + "[] memory " + ], + [ + "add", + "ed " + ], + [ + "as ", + "part " + ], + [ + "token ID", + " to " + ], + [ + "hex", + " " + ], + [ + "reentranc", + "y " + ], + [ + "name = name_;\\n ", + "_symbol = symbol_" + ], + [ + "C", + "umulative" + ], + [ + "}", + "(\\\"" + ], + [ + "it", + "al" + ], + [ + "balanceOf", + "(address(this" + ], + [ + "tim", + "elock" + ], + [ + "Per", + "iod" + ], + [ + "tokensFor", + "Dev" + ], + [ + "enal", + "ty" + ], + [ + "Den", + "ominator" + ], + [ + "balancer-", + "labs/" + ], + [ + "H", + "ow" + ], + [ + "R", + "IC" + ], + [ + "p", + "ending" + ], + [ + "\\n ", + " " + ], + [ + "for ", + "any " + ], + [ + "```", + "\\n *\\n * " + ], + [ + "By ", + "default" + ], + [ + "caller ", + "must " + ], + [ + "arithme", + "tic" + ], + [ + "on behalf ", + "of `owner" + ], + [ + "to ", + "learn more about " + ], + [ + "pl", + "icit" + ], + [ + "\\n * ", + "@param _" + ], + [ + "es[", + "role]." + ], + [ + "balancer-labs/", + "v2-" + ], + [ + "to", + "` cannot be the zero address" + ], + [ + "ic", + "t" + ], + [ + ",\\n ", + "bytes calldata data" + ], + [ + "mo", + "ve" + ], + [ + "swapExact", + "ETHFor" + ], + [ + "%%", + "%%" + ], + [ + "\"Ownable: ", + "new owner is " + ], + [ + ");\\n ", + "}\\n " + ], + [ + ") internal virtual {\\n ", + "uint256 " + ], + [ + "initial", + "ize" + ], + [ + "`owner` ", + "s " + ], + [ + "/= ", + "10" + ], + [ + "rele", + "ase" + ], + [ + "-", + "or" + ], + [ + "G", + "et " + ], + [ + "_", + "d" + ], + [ + "en", + "ables " + ], + [ + "pu", + "sh" + ], + [ + "..", + "." + ], + [ + ");\\n\\n ", + "// " + ], + [ + "\"// SPDX-License-Identifier: MIT", + "\\n\\n" + ], + [ + "pool", + " " + ], + [ + "cannot overflow", + ".\\n */\\n function " + ], + [ + "-or", + "-" + ], + [ + "typ", + "es " + ], + [ + "that is ", + "if it " + ], + [ + "msg.data", + ";\\n }\\n}\\n\"" + ], + [ + "security", + "/" + ], + [ + "updated", + "Index" + ], + [ + "ERC721.", + "ownerOf(tokenId" + ], + [ + "c", + "as" + ], + [ + "(address ", + "addr" + ], + [ + "This ", + "is " + ], + [ + "mul", + "Div" + ], + [ + "() external view returns (", + "address" + ], + [ + "NOT", + "_ENTERED" + ], + [ + ") external;\\n\\n ", + "/**\\n * @notice " + ], + [ + "Bl", + "acklist" + ], + [ + "\"Ownable: new owner is ", + "the zero address\"" + ], + [ + "(", + ") public virtual " + ], + [ + "l", + "imits" + ], + [ + "a ", + "- " + ], + [ + ";\\n ", + "}\\n }\\n\\n /**\\n * @dev " + ], + [ + "approve", + "Max" + ], + [ + "0.5", + "." + ], + [ + "er ", + "to " + ], + [ + "st", + "ate " + ], + [ + "af", + "t" + ], + [ + "\"// SPDX-License-Identifier: ", + "G" + ], + [ + "restr", + "ict " + ], + [ + "uint128", + " " + ], + [ + "`", + "approved" + ], + [ + "a", + "y " + ], + [ + "Of", + "(tokenId" + ], + [ + " is ", + "only " + ], + [ + "Pro", + "ject" + ], + [ + ".\\n * ", + "Returns 0 if given " + ], + [ + "}\\n\\n ", + "emit Transfer" + ], + [ + "modifier", + "\\n * " + ], + [ + "AC", + "H" + ], + [ + "spend", + " " + ], + [ + ") {\\n value ", + "/= " + ], + [ + ";\\n }\\n if (value ", + ">= " + ], + [ + ", of a positive value", + ".\\n * Returns 0 if given " + ], + [ + ", of a positive value.\\n * Returns 0 if given ", + "0" + ], + [ + "t", + "ack" + ], + [ + "to", + "ward" + ], + [ + "ar", + "m" + ], + [ + "sh", + "l" + ], + [ + "{\\n ", + "_" + ], + [ + "pa", + "used " + ], + [ + "Sign", + "ed " + ], + [ + "` is ", + "set " + ], + [ + "Non", + "-" + ], + [ + "@@@@@@@@@@@@@@@@", + "@@@@@@@@@@@@@@@@" + ], + [ + "avo", + "id" + ], + [ + "call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes", + "-string" + ], + [ + "Sal", + "es" + ], + [ + "/", + "src/" + ], + [ + "D", + "uration" + ], + [ + "or ", + "be an " + ], + [ + "max", + "Supply" + ], + [ + "encode", + "WithSignature" + ], + [ + "follow", + "ing " + ], + [ + "fic", + "i" + ], + [ + "Overflow", + " not " + ], + [ + "/**\\n * ", + "@notice " + ], + [ + "196", + "7" + ], + [ + "or be an ", + "approved operator" + ], + [ + "t", + "(" + ], + [ + "ERC", + "-" + ], + [ + ") {", + "\\n // " + ], + [ + "buy", + "MarketingFee" + ], + [ + "tokensFor", + "Marketing" + ], + [ + " bits", + "\\\");\\n return " + ], + [ + "An", + " " + ], + [ + "Renoun", + "c" + ], + [ + "can", + "Swap" + ], + [ + "allow", + " " + ], + [ + "_C", + "O" + ], + [ + "order", + "ing" + ], + [ + "Ethereum ", + "Signed " + ], + [ + "v", + "otes" + ], + [ + ") ", + "= _" + ], + [ + "ex", + "tra " + ], + [ + "red", + "uc" + ], + [ + " b", + "it" + ], + [ + "_beforeTokenTransfer", + "s" + ], + [ + ".sol'", + ";\\n" + ], + [ + "liqui", + "dity " + ], + [ + "#", + "(" + ], + [ + "//", + "\\n//" + ], + [ + "es", + ":" + ], + [ + ".sol\\\";\\n", + "import {" + ], + [ + "modul", + "o " + ], + [ + ", it ", + "is " + ], + [ + "_check", + "OnERC721Received" + ], + [ + "OPER", + "ATOR" + ], + [ + "along ", + "with " + ], + [ + "-", + "utils/" + ], + [ + "s", + "ome " + ], + [ + "it", + "e" + ], + [ + "_owner", + "s[tokenId" + ], + [ + "Set", + "ter" + ], + [ + "liquidity", + "Tokens" + ], + [ + "].", + "add(" + ], + [ + ";\\n }\\n\\n ", + "// " + ], + [ + "granted `role", + "`, emits a {Role" + ], + [ + "in", + "v" + ], + [ + "return", + "\\n " + ], + [ + "if", + "y" + ], + [ + "Math", + "." + ], + [ + "revert", + "ed" + ], + [ + "Updat", + "e the " + ], + [ + " := ", + "add(" + ], + [ + "2**", + "(" + ], + [ + "(address owner, address ", + "operator" + ], + [ + "D", + "ec" + ], + [ + "j", + "ust" + ], + [ + "le", + "ase " + ], + [ + "must ", + "use " + ], + [ + "\\r\\n ", + "* " + ], + [ + "Exceed", + "s the " + ], + [ + "`index", + "` " + ], + [ + "d", + "f" + ], + [ + "v", + "x" + ], + [ + "ti", + "cally " + ], + [ + "// ", + "solhint-disable-next-line " + ], + [ + "``", + "role" + ], + [ + "prod", + "0 " + ], + [ + "_balances[", + "to" + ], + [ + "safeTransferFrom", + "(\\n address from,\\n address to,\\n uint256 tokenId" + ], + [ + "_T", + "OKEN" + ], + [ + "isFee", + "Exempt" + ], + [ + "`owner` ", + "enables " + ], + [ + "RR", + "RR" + ], + [ + "cle", + "ar" + ], + [ + "Im", + "pl" + ], + [ + "w", + "ad" + ], + [ + "{", + "ERC165" + ], + [ + "e ", + "which " + ], + [ + "anc", + "e. " + ], + [ + "(uint256 ", + "_" + ], + [ + "] = ", + "amount" + ], + [ + ");\\n ", + "return " + ], + [ + "isApprovedForAll", + "(address owner, address operator" + ], + [ + "miss", + "ing " + ], + [ + "fi", + "eld" + ], + [ + "sel", + "ected " + ], + [ + "ECDSA", + ": invalid " + ], + [ + ";", + "\\n // " + ], + [ + "address", + "[] memory " + ], + [ + "at", + "es" + ], + [ + "from ", + "a " + ], + [ + "Burn", + "ed" + ], + [ + "Res", + "er" + ], + [ + "nonReentrant", + " " + ], + [ + "cop", + "y" + ], + [ + "laun", + "ch" + ], + [ + ";\\n emit Approval", + "(owner, " + ], + [ + "3", + "7" + ], + [ + "T", + "IP" + ], + [ + "to", + "-" + ], + [ + "IERC20", + "Permit" + ], + [ + "}\\n", + "\\n // " + ], + [ + " of the ", + "`" + ], + [ + "constructor", + " " + ], + [ + "two ", + "numbers" + ], + [ + "2**", + "256" + ], + [ + "size ", + ":= " + ], + [ + " may ", + "have " + ], + [ + "eth_", + "sign" + ], + [ + "set. O(1).\\n *\\n * ", + "Returns true if the " + ], + [ + "voting ", + "pow" + ], + [ + "tokens of ", + "at least" + ], + [ + "TIP", + ": " + ], + [ + "r", + "is" + ], + [ + "value", + ", recipient" + ], + [ + "balanceOf", + "}.\\n */\\n function " + ], + [ + "Max", + "TxAmount" + ], + [ + "Burn", + "Fee" + ], + [ + "(value", + ");\\n }\\n\\n /**\\n * @dev Returns the downcasted " + ], + [ + "e is ", + "used " + ], + [ + "send ", + "value, recipient" + ], + [ + "the caller must have ", + "allowance for " + ], + [ + "avo", + "id " + ], + [ + "unable to ", + "send value, recipient" + ], + [ + "Contract modul", + "e which " + ], + [ + "unable to send value, recipient", + " may have " + ], + [ + "b", + "oth" + ], + [ + "i", + "gr" + ], + [ + "r", + "aft" + ], + [ + "u", + "tu" + ], + [ + "on", + "-" + ], + [ + "ex", + "isting " + ], + [ + "length", + "(" + ], + [ + "With", + "Permit" + ], + [ + ";\\n ", + "uint256 private " + ], + [ + "wor", + "d" + ], + [ + "mstore", + "(" + ], + [ + ",,,,", + ",,,," + ], + [ + "-}[`functionCall`],\\n * but performing a ", + "delegate " + ], + [ + ");\\n\\n /**\\n * @dev Emitted when ", + "`owner` enables " + ], + [ + "address private ", + "_owner" + ], + [ + "address) {\\n return msg.sender", + ";\\n }\\n\\n function _msgData() internal view virtual returns (" + ], + [ + "Inf", + "o " + ], + [ + "address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (", + "bytes calldata" + ], + [ + ".", + "get" + ], + [ + "en", + "ce " + ], + [ + "amp", + "l" + ], + [ + "fee", + "Numerator" + ], + [ + "Sta", + "tu" + ], + [ + "modul", + "e is used " + ], + [ + "through ", + "inherit" + ], + [ + "make ", + "available " + ], + [ + "transfer(address ", + "recipient, uint256 amount" + ], + [ + "It will ", + "make available " + ], + [ + "ance. ", + "It will make available " + ], + [ + "module is used ", + "through inherit" + ], + [ + "module is used through inherit", + "ance. It will make available " + ], + [ + "\\n ", + "mapping(uint256 => " + ], + [ + "re", + "lat" + ], + [ + "en", + "ough " + ], + [ + "ad", + "e" + ], + [ + "= ", + "(" + ], + [ + " of ", + "all " + ], + [ + "on ", + "fail" + ], + [ + ", address ", + "p3) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(" + ], + [ + ", string memory ", + "p3) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(" + ], + [ + ")\\\", p0, p1, p2", + "));\\n\\t}\\n\\n\\tfunction " + ], + [ + "Au", + "ction" + ], + [ + ", bool ", + "p3) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(" + ], + [ + ")\\\", p0, p1, p2, p3));\\n\\t}\\n\\n\\tfunction ", + "log(address " + ], + [ + "amount exceeds balance", + "\\\");\\n unchecked {\\n " + ], + [ + "rounding ", + "direction" + ], + [ + ")\\\", p0, p1, p2, p3));\\n\\t}\\n\\n\\tfunction log(", + "bool " + ], + [ + ")\\\", p0, p1, p2, p3));\\n\\t}\\n\\n\\tfunction log(", + "string memory " + ], + [ + "call.\\n *\\n * _Available since v3.", + "4._\\n */\\n function " + ], + [ + "removeLiquidity", + "ETH" + ], + [ + "internal function is equivalent to ", + "{" + ], + [ + "indexed tokenId", + ");\\n\\n /**\\n * @dev Emitted when `owner` enables " + ], + [ + "-or-", + "later" + ], + [ + "ris", + "k" + ], + [ + "-}[`functionCall`],\\n * but performing a delegate ", + "call.\\n *\\n * _Available since v3.4._\\n */\\n function " + ], + [ + "1", + "] = " + ], + [ + "3", + "8" + ], + [ + "_", + "prevent" + ], + [ + "ed", + "\\n * " + ], + [ + ";\\n\\n", + "interface " + ], + [ + "for", + "um" + ], + [ + "Updat", + "es:" + ], + [ + "deploy", + "er " + ], + [ + "wor", + "d " + ], + [ + "approved ", + "for " + ], + [ + "_marketing", + "Fee" + ], + [ + "4", + "2" + ], + [ + "e", + "fficient" + ], + [ + "l", + "ong" + ], + [ + "ERC20", + "-" + ], + [ + "Pro", + "vider" + ], + [ + "decreased allowance below ", + "zero\"" + ], + [ + "set, ", + "that is if it " + ], + [ + "` is zero, `tokenId` ", + "will be " + ], + [ + ")\\\", p0, p1, p2, p3));\\n\\t\\tignored;\\n\\t}\\n\\n\\tfunction ", + "log(" + ], + [ + "set. O(1).\\n *\\n * Returns true if the ", + "value was " + ], + [ + "-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function ", + "functionDelegateCall" + ], + [ + ")", + "\\r\\n " + ], + [ + "\\n ", + "// " + ], + [ + "bytes memory ", + "buffer = new " + ], + [ + "Returns ", + "whether " + ], + [ + "using ", + "the " + ], + [ + "Ownable: ", + "caller is not the owner" + ], + [ + "string(", + "buffer" + ], + [ + "_prevent", + "Swap" + ], + [ + "bytes memory buffer = new ", + "bytes(" + ], + [ + "w", + "as" + ], + [ + "}", + "\\r\\n " + ], + [ + "approve", + "}." + ], + [ + "in the ", + "set. O(1" + ], + [ + "der", + "iv" + ], + [ + "Token ", + "Standard" + ], + [ + "||", + "\\n " + ], + [ + "token/ERC20/extensions/", + "IERC20Metadata" + ], + [ + "Merkle", + "Proof" + ], + [ + "correspond", + "ing\\n * " + ], + [ + "sti", + "ll " + ], + [ + "inverse *= 2 - denominator * inverse; // inverse mod ", + "2^" + ], + [ + " ", + "? " + ], + [ + "\"", + "log(" + ], + [ + "[", + "account" + ], + [ + "ERC20", + "Burnable" + ], + [ + " = ", + "value" + ], + [ + ";\\n ", + "using " + ], + [ + "utils/", + "Address" + ], + [ + "sell", + "DevFee" + ], + [ + "}.", + "\\n * - " + ], + [ + "remove", + "(" + ], + [ + "][", + "operator" + ], + [ + "Round", + "ing." + ], + [ + "s `amount` tokens from ", + "`account`, " + ], + [ + ".\\n */\\n function symbol", + "() external view returns (string memory);\\n\\n /**\\n * @dev Returns the " + ], + [ + "TransferTo", + "Non" + ], + [ + "Fungi", + "ble " + ], + [ + "ci", + "rc" + ], + [ + "``role", + "``'s " + ], + [ + "=", + "-" + ], + [ + "U", + "M" + ], + [ + "_", + "paused" + ], + [ + "In", + "E" + ], + [ + "typ", + "e " + ], + [ + "Del", + "et" + ], + [ + "transfer to ", + "non " + ], + [ + "_final", + "BuyTax" + ], + [ + "divisor cannot be ", + "zero.\\n */\\n function " + ], + [ + "caller must ", + "own" + ], + [ + "_", + "LI" + ], + [ + "m", + "arket" + ], + [ + "\\n ", + "}\\n " + ], + [ + "exp", + "ir" + ], + [ + "_F", + "I" + ], + [ + "S", + "c" + ], + [ + "`", + "isContract" + ], + [ + "h", + "and" + ], + [ + "uint256 ", + "c = " + ], + [ + "\\n * ", + "to " + ], + [ + ".\\n */\\n function ", + "totalSupply() external view returns (uint256" + ], + [ + " != ", + "0) {\\n " + ], + [ + ", address indexed ", + "newOwner" + ], + [ + "sqrt", + "(a" + ], + [ + "ized", + "Weight" + ], + [ + ".sol';\\n", + "import '" + ], + [ + "G", + "as" + ], + [ + "P", + "RO" + ], + [ + "T", + "able" + ], + [ + "i", + "le" + ], + [ + "j", + "ect " + ], + [ + "This ", + "function " + ], + [ + "Mint", + "ed(" + ], + [ + "_A", + "U" + ], + [ + ". This ", + "is the " + ], + [ + "uint amount", + "Out" + ], + [ + ";\\n }\\n\\n function ", + "set" + ], + [ + "ne", + "ed" + ], + [ + "_balances[account", + "] = " + ], + [ + "kn", + "own " + ], + [ + "Interface of the ", + "ERC20 " + ], + [ + "0.7", + ".0" + ], + [ + "Non-", + "Fungible " + ], + [ + "a", + "ke" + ], + [ + "is", + "ting" + ], + [ + ";\\n ", + "}\\n\\n " + ], + [ + "contract ", + "recipient" + ], + [ + "man", + "ual" + ], + [ + " ", + " " + ], + [ + "follow", + "ing the " + ], + [ + "ERC721Receiver", + "Implementer" + ], + [ + "Pres", + "et" + ], + [ + "call to non-contract\\\");\\n\\n ", + "(bool success, bytes memory returndata) = target" + ], + [ + "TransferToNon", + "ERC721ReceiverImplementer" + ], + [ + "b", + "0" + ], + [ + "tr", + "ig" + ], + [ + ");", + "\\r\\n " + ], + [ + "end", + "ing " + ], + [ + "is", + "tor" + ], + [ + "ERC", + "1155" + ], + [ + "ri", + "ght" + ], + [ + "Co", + "mp" + ], + [ + "\"SafeMath: ", + "addition" + ], + [ + "\"SafeMath: ", + "multiplication overflow" + ], + [ + ") internal returns (bytes memory", + ") {\\n require(" + ], + [ + "from `from` to `to", + "`" + ], + [ + "[0", + "] = " + ], + [ + " the token ", + "or be an approved operator" + ], + [ + "Rounding ", + "rounding" + ], + [ + "functional", + "ity " + ], + [ + "ACH", + "ED" + ], + [ + "caller must own", + " the token or be an approved operator" + ], + [ + "B", + "pt" + ], + [ + " == ", + "address(0)" + ], + [ + "must be ", + "greater than " + ], + [ + "\\n /// ", + "@dev " + ], + [ + "https://eips.ethereum.org/EIPS/eip-", + "721" + ], + [ + "\"SafeMath: ", + "division by " + ], + [ + "\"SafeMath: ", + "subtraction" + ], + [ + "utils/Context", + ".sol\"" + ], + [ + "(to, ", + "tokenId" + ], + [ + "approve(address spender, uint256 amount", + ") external returns (bool" + ], + [ + "\"SafeMath: addition", + " overflow\"" + ], + [ + "\"SafeMath: multiplication overflow", + "\"" + ], + [ + "p", + "id" + ], + [ + "t", + "Supply" + ], + [ + "as ", + "defined " + ], + [ + "== ", + "address(0)" + ], + [ + ") external", + ";\\n}\\n\"" + ], + [ + "transferOwnership", + "(address newOwner" + ], + [ + "▓▓", + "▓▓" + ], + [ + "spend", + "Allowance" + ], + [ + "BP", + "T" + ], + [ + "mint to ", + "the zero address\"" + ], + [ + "rounded ", + "toward" + ], + [ + "\"SafeMath: division by ", + "zero\"" + ], + [ + "'s ", + "balance " + ], + [ + "block", + "s" + ], + [ + "more ", + "expensi" + ], + [ + "(address indexed ", + "previousOwner" + ], + [ + "IM", + "E" + ], + [ + "renounceOwnership", + "() public virtual " + ], + [ + "Multi", + "p" + ], + [ + ") {\\n _", + "name = name_;\\n _symbol = symbol_" + ], + [ + "ERC721Receiver ", + "implementer" + ], + [ + "transfer to non ", + "ERC721Receiver implementer" + ], + [ + "R", + "andom" + ], + [ + ".s", + "tart" + ], + [ + "hash", + "ed" + ], + [ + "\\n * ", + "@param " + ], + [ + "++", + ";\\n " + ], + [ + "later", + "al " + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.", + "8" + ], + [ + ") internal virtual {", + "}\\n\\n /**\\n * @dev " + ], + [ + "custom ", + "message " + ], + [ + "Rounding.", + "Up" + ], + [ + ", ", + "bytes memory " + ], + [ + "\\\"", + ", " + ], + [ + "con", + "si" + ], + [ + "chain", + "id" + ], + [ + "separ", + "at" + ], + [ + "selected ", + "rounding direction" + ], + [ + "following the ", + "selected rounding direction" + ], + [ + "(address indexed previousOwner", + ", address indexed newOwner" + ], + [ + "tu", + "n" + ], + [ + "\\n * ", + "@dev " + ], + [ + "as", + "ed" + ], + [ + "be", + "gin" + ], + [ + "totalSupply", + "() public view virtual override returns (" + ], + [ + "\\r\\n ", + "event " + ], + [ + "ST", + "A" + ], + [ + "Sub", + "tr" + ], + [ + "decreased allowance below ", + "zero" + ], + [ + "Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with ", + "meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (" + ], + [ + "provide", + "s a " + ], + [ + "address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata", + ") {\\n return " + ], + [ + "O", + "u" + ], + [ + "h", + "ase" + ], + [ + "\\n ", + ") internal pure returns (" + ], + [ + "s ", + "is " + ], + [ + ", ", + "newOwner" + ], + [ + "(address ", + "sender" + ], + [ + "total", + "Hash" + ], + [ + "value ", + "failed" + ], + [ + "be", + "\\n * " + ], + [ + "with ", + "value failed" + ], + [ + "mul", + "mod" + ], + [ + "call ", + "with value failed" + ], + [ + "ER_", + "REGISTRY" + ], + [ + "LT", + "ER_REGISTRY" + ], + [ + "Internal ", + "function " + ], + [ + "balance for ", + "call" + ], + [ + "VR", + "F" + ], + [ + "beare", + "r" + ], + [ + "OPERATOR", + "_FI" + ], + [ + "_preventSwap", + "Before" + ], + [ + "OPERATOR_FI", + "LTER_REGISTRY" + ], + [ + "E", + "vent" + ], + [ + "p", + "ass" + ], + [ + "address", + ") {\\n " + ], + [ + "get", + "RoleAdmin" + ], + [ + "s the ", + "contract" + ], + [ + ") internal pure returns (uint256) {\\n ", + "unchecked {\\n " + ], + [ + "(uint256 a, uint256 b) internal pure returns (", + "bool, " + ], + [ + "_final", + "SellTax" + ], + [ + "Non-Fungible ", + "Token Standard" + ], + [ + "s ", + "this " + ], + [ + "Ad", + "d " + ], + [ + "with", + "\\n * `" + ], + [ + "min", + "imum" + ], + [ + "Own", + "able is Context " + ], + [ + "Total", + "Fee" + ], + [ + "/EIP", + "s/" + ], + [ + "77", + "7" + ], + [ + "https://github.com/ethereum", + "/EIPs/" + ], + [ + "clusi", + "ve " + ], + [ + "\"SafeMath: subtraction", + " overflow\"" + ], + [ + "3", + "1" + ], + [ + "ti", + "es " + ], + [ + ") ", + "|" + ], + [ + "a ", + "function call" + ], + [ + "dev", + "Wallet" + ], + [ + "in ", + "construction" + ], + [ + ";\\n ", + "require(" + ], + [ + "== ", + "Rounding.Up" + ], + [ + "swap", + "Back" + ], + [ + "OwnershipTransferred", + "(address indexed previousOwner, address indexed newOwner" + ], + [ + "rounding ", + "== Rounding.Up" + ], + [ + ");\\n }", + "\\n }\\n\\n function " + ], + [ + "rel", + "ation" + ], + [ + "rounding == Rounding.Up", + " && " + ], + [ + "%", + " b" + ], + [ + ", ", + "since " + ], + [ + "un", + "realis" + ], + [ + "`.", + "\\n // - `" + ], + [ + ";\\n\\nimport \\\"", + "../" + ], + [ + "me", + "ans" + ], + [ + "called by ", + "any " + ], + [ + "approvedAddress", + "Slot" + ], + [ + "/*", + "//////////////////////////////////////////////////////////////" + ], + [ + ",\\r\\n address ", + "to" + ], + [ + "(address from, address ", + "to, uint256 amount" + ], + [ + ";\\n\\n // Mapping from ", + "token ID to " + ], + [ + "_msgSender(), \\\"", + "Ownable: caller is not the owner" + ], + [ + "Updates:", + "\\n // - `" + ], + [ + "B", + "ool" + ], + [ + "`", + "approve" + ], + [ + "ex", + "plicit" + ], + [ + ",\\n ", + "// " + ], + [ + "for ", + "{" + ], + [ + "can ", + "then " + ], + [ + "`from", + "` " + ], + [ + ");\\n\\n /**\\n * @dev ", + "Emitted when the " + ], + [ + "struct ", + "the " + ], + [ + "specif", + "ication" + ], + [ + "Metadata ", + "is " + ], + [ + "config", + "." + ], + [ + "() public view virtual override returns (string memory) {\\n return ", + "_symbol" + ], + [ + "() public view virtual override returns (string memory) {\\n return ", + "_name" + ], + [ + "string memory name_, string memory symbol_", + ") {\\n _name = name_;\\n _symbol = symbol_" + ], + [ + "relation", + "ship" + ], + [ + ")", + "\\n " + ], + [ + "A", + "M" + ], + [ + "[", + "IMPORTANT" + ], + [ + "int", + "24" + ], + [ + ". ", + "On" + ], + [ + "po", + "ch" + ], + [ + "pa", + "us" + ], + [ + "_set", + "AutomatedMarketMakerPair" + ], + [ + "by", + "\\n * `" + ], + [ + "maximum", + " `" + ], + [ + "html", + "#" + ], + [ + "log2", + "(a" + ], + [ + "_owner = ", + "newOwner" + ], + [ + "Throws if ", + "called by any " + ], + [ + " ", + "|" + ], + [ + "a ", + "% b" + ], + [ + "contract", + "s" + ], + [ + "Message", + "Hash" + ], + [ + ") private ", + "pure returns (" + ], + [ + "msg.", + "value" + ], + [ + "number of tokens ", + "that " + ], + [ + "access ", + "control " + ], + [ + "counter", + "._" + ], + [ + "(", + "string " + ], + [ + ",", + "address " + ], + [ + "4", + "4" + ], + [ + "P", + "erform" + ], + [ + "ac", + "on" + ], + [ + "ERC20", + "Preset" + ], + [ + "li", + "ght" + ], + [ + " is ", + "IERC165 {\\n /**\\n * @dev " + ], + [ + "com", + "ment" + ], + [ + "\"ERC20: ", + "decreased allowance below zero\"" + ], + [ + "Par", + "t" + ], + [ + ".sol\\\";\\n\\n", + "contract " + ], + [ + ")\\n external", + "\\n " + ], + [ + "pur", + "ch" + ], + [ + "//////////////////////////////////////////////////////////////", + "*/" + ], + [ + "E", + "quivalent to " + ], + [ + "de", + "cl" + ], + [ + "owner", + " to " + ], + [ + "wh", + "ere" + ], + [ + "In", + "sufficient" + ], + [ + "ay", + "er" + ], + [ + "proof", + "Flag" + ], + [ + "available ", + "to " + ], + [ + "assum", + "e that " + ], + [ + "from the caller", + "'s\\n * " + ], + [ + "https://github.com/ethereum/EIPs/", + "issues/" + ], + [ + "ei", + "l" + ], + [ + " for ", + "uint256" + ], + [ + "exp", + "Table" + ], + [ + "edi", + "a" + ], + [ + "startTokenId", + ", " + ], + [ + "owner ", + "nor " + ], + [ + "when", + "ever " + ], + [ + "uint160", + "(" + ], + [ + "tryRecover", + "(hash" + ], + [ + "from the caller's\\n * ", + "allowance" + ], + [ + "E", + "O" + ], + [ + "S", + "to" + ], + [ + "`", + "\\n // - " + ], + [ + "c", + "y " + ], + [ + "amount", + "ToSwap" + ], + [ + "20", + "#" + ], + [ + "72", + "9" + ], + [ + "con", + "ver" + ], + [ + "next", + "TokenId " + ], + [ + "ating ", + "the " + ], + [ + "onERC721Received", + ".selector" + ], + [ + "amountB", + "Min" + ], + [ + "amountA", + "Min" + ], + [ + ".\\n */\\ninterface ", + "IERC20" + ], + [ + "setting ", + "the " + ], + [ + "normal", + "izedWeight" + ], + [ + "HEX", + "_SYMBOLS" + ], + [ + "Ref", + "lection" + ], + [ + "`\\n // - ", + "[" + ], + [ + "a", + "th" + ], + [ + "s ", + "`role" + ], + [ + "owner", + ". " + ], + [ + ".\\n */\\n function ", + "get" + ], + [ + "up", + "grad" + ], + [ + "0x", + "0" + ], + [ + "returns (bool", + ") {\\n return _" + ], + [ + "` is ", + "allowed to " + ], + [ + "Marketing", + "Wallet" + ], + [ + "|| ", + "super.supportsInterface(interfaceId" + ], + [ + "erc", + "721" + ], + [ + "(account, address(0), ", + "amount" + ], + [ + "new owner is ", + "the zero address" + ], + [ + "impos", + "sible " + ], + [ + "guarant", + "e" + ], + [ + "transferOwnership(address newOwner", + ") public virtual " + ], + [ + "b", + "orrow" + ], + [ + "m", + "u" + ], + [ + "s ", + "an " + ], + [ + "pro", + "vide " + ], + [ + "bytes32", + " _" + ], + [ + "> ", + "0) {\\n " + ], + [ + "vo", + "ting" + ], + [ + "version", + " of " + ], + [ + "packedOwnership", + "s[" + ], + [ + "instead", + " " + ], + [ + "upgrade", + "able" + ], + [ + "When `from", + "` and `to` are both non-zero, " + ], + [ + "ex", + "tra" + ], + [ + ". ", + "S" + ], + [ + "`amount", + "` is " + ], + [ + "Ownable: ", + "new owner is the zero address" + ], + [ + "abil", + "ity " + ], + [ + "division by ", + "zero" + ], + [ + "bas", + "ic " + ], + [ + "exce", + "pt " + ], + [ + "Signed", + "MessageHash" + ], + [ + "Cle", + "ar " + ], + [ + "recon", + "struct the " + ], + [ + "S", + "_" + ], + [ + "_", + "baseURI" + ], + [ + "l", + "imit " + ], + [ + "n", + "ft " + ], + [ + "int", + "eres" + ], + [ + "\\n * ", + "a " + ], + [ + "acc", + "e" + ], + [ + ";\\n ", + "while (" + ], + [ + "ta", + "k" + ], + [ + "LE", + "NG" + ], + [ + "non-", + "zero " + ], + [ + "uint amount", + "In" + ], + [ + "account ", + "other than " + ], + [ + "there ", + "is " + ], + [ + "Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (", + "address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return " + ], + [ + "[IMPORTANT", + "]\\n * ====\\n * " + ], + [ + "D", + "is" + ], + [ + "U", + "B" + ], + [ + "b", + "ased " + ], + [ + "t", + "/" + ], + [ + "x", + "_" + ], + [ + "en", + "for" + ], + [ + ", ", + "msg.sender" + ], + [ + "\\n * ", + "`amount" + ], + [ + "from", + "Balance " + ], + [ + "{\\n ", + "using " + ], + [ + "there", + "by " + ], + [ + "pool", + "Id" + ], + [ + " bits", + "\\n *\\n * _Available since v4.7._\\n */\\n function " + ], + [ + "address) {\\n return ", + "_owner" + ], + [ + "} else {\\n ", + "return " + ], + [ + "MaxTxAmount", + "Updated" + ], + [ + "Throws if called by any ", + "account other than " + ], + [ + "(", + "uint " + ], + [ + "en", + "\\n * " + ], + [ + "(uint256 ", + "index" + ], + [ + ")\\n ", + "internal" + ], + [ + "Chang", + "ed(" + ], + [ + "0000000000000000", + "0000000000000000" + ], + [ + "revert reason ", + "is " + ], + [ + "you ", + "can " + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - The ", + "divisor cannot be zero.\\n */\\n function " + ], + [ + "(\\n address target,\\n bytes memory data", + ",\\n uint256 value" + ], + [ + "_packedOwnership", + "s[" + ], + [ + "(data);\\n return verifyCallResult", + "(success, returndata, errorMessage" + ], + [ + "S", + "afely transfers `tokenId` token from `from` to `to" + ], + [ + "_", + "index" + ], + [ + "_", + "packedAddressData" + ], + [ + "s ", + "on " + ], + [ + "fun", + "d " + ], + [ + "= ", + "false" + ], + [ + "af", + "f" + ], + [ + "low", + "er than " + ], + [ + "] = ", + "to" + ], + [ + "Eth", + "SignedMessageHash" + ], + [ + "defined ", + "by\\n * `" + ], + [ + "some", + "one " + ], + [ + "Addition", + "ally, " + ], + [ + "bi", + "tr" + ], + [ + "Decim", + "als" + ], + [ + "deriv", + "ed " + ], + [ + "LENG", + "TH" + ], + [ + "p", + "s" + ], + [ + "p", + "or" + ], + [ + "de", + "s" + ], + [ + "return", + "datasize" + ], + [ + "is", + "\\n * " + ], + [ + "\\r", + "\\n // " + ], + [ + "val", + "i" + ], + [ + "ri", + "es" + ], + [ + " = ", + "_owner" + ], + [ + "in ", + "a " + ], + [ + "lea", + "ve the " + ], + [ + "_balances[", + "sender" + ], + [ + "then ", + "deduc" + ], + [ + "shr", + "(" + ], + [ + "roll", + "er" + ], + [ + "\\n virtual", + "\\n override" + ], + [ + "both", + " the " + ], + [ + ":", + "\\n *\\n * " + ], + [ + "C", + "O" + ], + [ + "M", + "y" + ], + [ + "_", + "update" + ], + [ + "\\\"", + ");\\n " + ], + [ + "from ", + "one " + ], + [ + "\"ERC20: ", + "burn " + ], + [ + "_tokenApproval", + "s" + ], + [ + "issue", + "comment" + ], + [ + "b", + "reak" + ], + [ + "g", + "overn" + ], + [ + "s ", + "from the " + ], + [ + "to", + "EthSignedMessageHash" + ], + [ + "uint", + "[] memory " + ], + [ + ",\\n ", + "uint256[] memory " + ], + [ + "for ", + "`owner" + ], + [ + ") {\\n return ", + "interfaceId == type(" + ], + [ + "fo", + "rever" + ], + [ + ".\\n */\\n function _", + "mint" + ], + [ + "utils/", + "Strings" + ], + [ + "returndata", + ".length" + ], + [ + ".\\n *\\n * _Available since v3.", + "4._\\n */\\n function " + ], + [ + "\"ERC20: transfer ", + "amount exceeds balance\"" + ], + [ + "tokens of at least", + "\\n * `amount" + ], + [ + "5", + "8" + ], + [ + "`", + ": " + ], + [ + "`", + "onlyOwner" + ], + [ + "m", + "atch" + ], + [ + "256", + " " + ], + [ + ".\\n *\\n * ", + "@param " + ], + [ + ".sol\\\"", + ";\\n\\n/**\\n * @title " + ], + [ + "Swap", + "Threshold" + ], + [ + "| ", + "|" + ], + [ + "When ", + "`to" + ], + [ + "address of the ", + "current owner" + ], + [ + "ownership.", + "addr" + ], + [ + "(int256 ", + "value" + ], + [ + ".\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue", + "(\\n address target,\\n bytes memory data,\\n uint256 value" + ], + [ + "`amount` is ", + "then deduc" + ], + [ + "Throws if called by any account other than ", + "the owner" + ], + [ + ".\\n *\\n * _Available since v3.4._\\n */\\n function ", + "try" + ], + [ + "tokens of at least\\n * `amount", + "`.\\n */\\n function " + ], + [ + "F", + "ixed" + ], + [ + ". ", + "See the " + ], + [ + "low", + "er" + ], + [ + "0.", + "4." + ], + [ + ", address ", + "_" + ], + [ + ").", + "length" + ], + [ + "`.", + "\\n _" + ], + [ + "only ", + "available to " + ], + [ + "35", + "24" + ], + [ + "::::", + "::::" + ], + [ + "transferred to `to`.\\n * - ", + "When `from" + ], + [ + ". The result is ", + "rounded toward" + ], + [ + "Hel", + "per" + ], + [ + "%", + "\"" + ], + [ + "C", + "AU" + ], + [ + "I", + "TH" + ], + [ + ", ", + "or " + ], + [ + "ex", + "clusive " + ], + [ + "ing ", + "ownership " + ], + [ + "air", + "drop" + ], + [ + "bytes32 ", + "public constant " + ], + [ + " b", + "etwe" + ], + [ + "allowance ", + "to " + ], + [ + ");\\n return ", + "(" + ], + [ + "mar", + "y" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.", + "7" + ], + [ + "as the ", + "initial " + ], + [ + "HASH", + "ED" + ], + [ + " of two unsigned integers, ", + "reverting " + ], + [ + "transfer(address ", + "to, uint256 amount" + ], + [ + "}\\n * ", + "```\\n *\\n * " + ], + [ + "-26", + "3524" + ], + [ + "https://github.com/ethereum/EIPs/issues/", + "20#" + ], + [ + "owner. ", + "It will " + ], + [ + "issuecomment", + "-263524" + ], + [ + "CAU", + "TION" + ], + [ + "https://github.com/ethereum/EIPs/issues/20#", + "issuecomment-263524" + ], + [ + "https://github.com/ethereum/EIPs/issues/20#issuecomment-263524", + "729" + ], + [ + "\"", + "Exceeds the " + ], + [ + ".\\n *", + " " + ], + [ + "balanc", + "es " + ], + [ + "--", + "-" + ], + [ + "sy", + "nc" + ], + [ + "will ", + "leave the " + ], + [ + "for", + "tun" + ], + [ + "{\\n ", + "address private _owner" + ], + [ + "recei", + "ved " + ], + [ + "any ", + "functionality " + ], + [ + "that is ", + "only available to " + ], + [ + "mechanism", + ". " + ], + [ + "ob", + "bl" + ], + [ + "dur", + "ation" + ], + [ + "ethFor", + "Liquidity" + ], + [ + " == 0", + ") {\\n " + ], + [ + "(to", + ")." + ], + [ + "contract without ", + "an owner" + ], + [ + ")) private ", + "_allowances" + ], + [ + "By default", + ", " + ], + [ + "Renounc", + "ing ownership " + ], + [ + "Clear ", + "approval" + ], + [ + "will leave the ", + "contract without an owner" + ], + [ + "any functionality ", + "that is only available to " + ], + [ + "Renouncing ownership ", + "will leave the contract without an owner" + ], + [ + "F", + "allback" + ], + [ + "W", + "ITH" + ], + [ + "\\n * ", + "of " + ], + [ + "transfer", + "ring " + ], + [ + ") internal ", + "{\\n require(" + ], + [ + "MIT", + " " + ], + [ + ";\\n }\\n\\n /**\\n * @dev See {", + "IERC721Metadata" + ], + [ + "Initializ", + "able" + ], + [ + "access ", + "restriction" + ], + [ + "call failed", + "\"" + ], + [ + "flag", + ".\\n *\\n * _Available since v3.4._\\n */\\n function try" + ], + [ + "Initializes the contract ", + "setting the " + ], + [ + "Creat", + "es " + ], + [ + "B", + "it" + ], + [ + "S", + "tore" + ], + [ + "In", + "valid " + ], + [ + "string", + "(abi.encode" + ], + [ + ") public ", + "view override returns (" + ], + [ + " is ", + "to " + ], + [ + "not be ", + "possible to " + ], + [ + ",\\n address ", + "_" + ], + [ + "(from, to, ", + "amount);\\n\\n " + ], + [ + "them", + " to " + ], + [ + ",\\n ", + "uint256 " + ], + [ + "contract without ", + "owner. It will " + ], + [ + "Lea", + "ves the " + ], + [ + "forum", + "." + ], + [ + "deployer ", + "as the initial " + ], + [ + "any functionality that is only available to ", + "the owner" + ], + [ + "not be possible to ", + "call" + ], + [ + "contract without owner. It will ", + "not be possible to call" + ], + [ + "Leaves the ", + "contract without owner. It will not be possible to call" + ], + [ + "0", + "e" + ], + [ + "5", + "12" + ], + [ + "s ", + "on the " + ], + [ + "un", + "fortun" + ], + [ + "all", + "Pair" + ], + [ + "function ", + "call " + ], + [ + "Ex", + "cludeFrom" + ], + [ + "\\r\\n ", + "// " + ], + [ + "Safe", + "ERC20: " + ], + [ + "allowance ", + "by " + ], + [ + "Pay", + "ee" + ], + [ + "our", + "ce " + ], + [ + "after", + "ward" + ], + [ + "26", + "12" + ], + [ + "without ", + "access restriction" + ], + [ + "_C", + "ACHED" + ], + [ + "there ", + "is an " + ], + [ + "& _", + "BITMASK" + ], + [ + "und", + "erflow" + ], + [ + "Internal function ", + "without access restriction" + ], + [ + " ", + "or" + ], + [ + "\"", + "Cannot " + ], + [ + "O", + "F" + ], + [ + "d", + "raft" + ], + [ + "}", + ". This " + ], + [ + "se", + "aDrop" + ], + [ + "owner", + "() public view virtual returns (" + ], + [ + "data", + "` " + ], + [ + "swap", + "Threshold" + ], + [ + "newOwner", + " != address(0), \\\"" + ], + [ + "Role", + "Member" + ], + [ + "Tax", + "Swap" + ], + [ + "transfer to ", + "the zero address\\\");\\n\\n _beforeTokenTransfer" + ], + [ + "protocol", + " " + ], + [ + "0.5", + ".0" + ], + [ + "sec", + "uti" + ], + [ + "ateg", + "y" + ], + [ + "renounceOwnership() public virtual ", + "onlyOwner {\\n " + ], + [ + "Initializes the contract setting the ", + "deployer as the initial " + ], + [ + ".", + "add(" + ], + [ + "I", + "t" + ], + [ + "_", + "lock" + ], + [ + "b", + "3" + ], + [ + "h", + "ere" + ], + [ + "\\n ", + "//////////////////////////////////////////////////////////////*/" + ], + [ + "address", + "es " + ], + [ + "ing", + "\\n * " + ], + [ + "/**", + "\\n * @dev " + ], + [ + ". ", + "If " + ], + [ + "only", + "Role(" + ], + [ + ");\\n\\n ", + "/// @notice " + ], + [ + "log", + "256" + ], + [ + "log", + "10" + ], + [ + ") {\\n ", + "revert " + ], + [ + ". This ", + "function " + ], + [ + ", and ", + "the " + ], + [ + ".\\n *\\n * Emits an {Approval", + "} event.\\n *\\n * Requirements:\\n *\\n * - `" + ], + [ + "minted for `to`.\\n * - ", + "When `to" + ], + [ + "[]", + "(" + ], + [ + "optional ", + "metadata " + ], + [ + "_balances[to", + "] += " + ], + [ + "Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return ", + "msg.data;\\n }\\n}\\n\"" + ], + [ + "{", + "decimals} " + ], + [ + "bytes", + "16" + ], + [ + "row", + "th" + ], + [ + "ind", + "ow" + ], + [ + ") revert ", + "Mint" + ], + [ + "mechanism", + ", " + ], + [ + ";\\r\\n }\\r\\n", + "\\r\\n /**\\r\\n * @dev " + ], + [ + "` to `", + "recipient" + ], + [ + "Hook that is called ", + "after " + ], + [ + "tokens are ", + "moved " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Destroy", + "s `amount` tokens from `account`, " + ], + [ + ", of a positive value.\\n * Returns 0 if given 0", + ".\\n */\\n function " + ], + [ + "ERC20Preset", + "Minter" + ], + [ + "Initializes the contract setting the deployer as the initial ", + "owner" + ], + [ + " ", + "+= " + ], + [ + "+", + " _" + ], + [ + ",", + "\\n " + ], + [ + "G", + "i" + ], + [ + "O", + "W" + ], + [ + "x", + "s" + ], + [ + "═", + "═" + ], + [ + "on", + "e that " + ], + [ + "min", + "er" + ], + [ + "up", + "d" + ], + [ + "ers", + ". " + ], + [ + ")\\n external", + "\\n view\\n returns (" + ], + [ + "value of ", + "18" + ], + [ + "_allowances[owner][spender", + "] = amount" + ], + [ + "`sender", + "` to `recipient" + ], + [ + "prot", + "ect " + ], + [ + "newOwner != address(0), \\\"", + "Ownable: new owner is the zero address" + ], + [ + "-", + "1" + ], + [ + "/", + "[" + ], + [ + "E", + "L" + ], + [ + "U", + "nd" + ], + [ + "_", + "previous" + ], + [ + "}", + "\\r\\n }\\r\\n" + ], + [ + "In", + "itial" + ], + [ + "param", + "s." + ], + [ + "`from", + "`) " + ], + [ + "deploy", + "s the contract" + ], + [ + "\\u003", + "e" + ], + [ + "execu", + "tion" + ], + [ + "NFT", + " " + ], + [ + "and the ", + "new " + ], + [ + "transaction ", + "ordering" + ], + [ + ").interfaceId ", + "|| super.supportsInterface(interfaceId" + ], + [ + "provid", + "ed " + ], + [ + "registe", + "red " + ], + [ + "br", + "ing" + ], + [ + "owner() ", + "== " + ], + [ + "(", + "`to" + ], + [ + "B", + "ew" + ], + [ + "d", + "on" + ], + [ + ", ", + "bool _" + ], + [ + "ER", + "O" + ], + [ + "spender", + "` cannot be the zero address.\\n * - `" + ], + [ + " to ", + "mitig" + ], + [ + "pl", + "at" + ], + [ + "decimals", + "_" + ], + [ + "hash", + "ed " + ], + [ + "allowance ", + "mechanism. " + ], + [ + "last", + "TokenIndex" + ], + [ + "integ", + "er " + ], + [ + "sol", + "ution" + ], + [ + "account (", + "`from`) " + ], + [ + "another ", + "(`to" + ], + [ + "setFee", + "To" + ], + [ + "limits", + "InE" + ], + [ + ". On", + "e " + ], + [ + "from one ", + "account (`from`) " + ], + [ + "uint[] memory ", + "amounts" + ], + [ + "bl", + "e" + ], + [ + "s the ", + "risk" + ], + [ + "value ", + "afterward" + ], + [ + "that ", + "changing " + ], + [ + "that ", + "someone " + ], + [ + "with ", + "this method " + ], + [ + "are ", + "that changing " + ], + [ + "ate ", + "this " + ], + [ + "new ", + "allowance" + ], + [ + "use ", + "both the " + ], + [ + "`value", + "` is the " + ], + [ + "first ", + "reduce the " + ], + [ + "condition", + " is to " + ], + [ + "plac", + "es " + ], + [ + "possible ", + "solution" + ], + [ + "allowed to ", + "spend " + ], + [ + "vot", + "es " + ], + [ + "_reduce", + "BuyTax" + ], + [ + "getAmount", + "s" + ], + [ + "taken", + " to " + ], + [ + "dest", + "roy" + ], + [ + "_ST", + "AR" + ], + [ + "an allowance ", + "with this method " + ], + [ + "transaction ordering", + ". One " + ], + [ + "bring", + "s the risk" + ], + [ + "Bew", + "are that changing " + ], + [ + "first reduce the ", + "spender" + ], + [ + "condition is to ", + "first reduce the spender" + ], + [ + "an allowance with this method ", + "brings the risk" + ], + [ + "transaction ordering. One ", + "possible solution" + ], + [ + "Beware that changing ", + "an allowance with this method brings the risk" + ], + [ + "K", + "e" + ], + [ + "el", + "y" + ], + [ + "tokenId", + ");\\n\\n " + ], + [ + ") public ", + "payable " + ], + [ + "uint8", + ") {\\n return " + ], + [ + "allowance ", + "of a " + ], + [ + "remain", + "der" + ], + [ + "`owner", + "` is set " + ], + [ + "`spender` ", + "for an " + ], + [ + "Note that ", + "`value` " + ], + [ + "`value` ", + "tokens are moved " + ], + [ + "If the ", + "next " + ], + [ + ");\\n ", + "}\\n\\n " + ], + [ + "Com", + "put" + ], + [ + " != address(0), \\\"ERC20: approve ", + "to " + ], + [ + "may be ", + "zero" + ], + [ + "0 and ", + "set " + ], + [ + "on fail", + "ure" + ], + [ + "`amount` is then deduc", + "ted " + ], + [ + "allowance to ", + "0 and set " + ], + [ + "allowance by ", + "unfortun" + ], + [ + "and the new ", + "allowance by unfortun" + ], + [ + "`value` is the ", + "new allowance" + ], + [ + "_reduceBuyTax", + "At" + ], + [ + "allowance of a ", + "`spender` for an " + ], + [ + "`owner` is set ", + "by" + ], + [ + "Note that `value` ", + "may be zero" + ], + [ + "`value` tokens are moved ", + "from one account (`from`) " + ], + [ + "allowance of a `spender` for an ", + "`owner` is set by" + ], + [ + "H", + "and" + ], + [ + "Z", + "ERO" + ], + [ + "c", + "eil" + ], + [ + "s", + "k" + ], + [ + ") ", + "that can be " + ], + [ + "/**\\n * ", + "Returns the " + ], + [ + "ab", + "c" + ], + [ + "zero ", + "by default" + ], + [ + "the", + "\\n // " + ], + [ + "import \\\"", + "@openzeppelin/contracts/" + ], + [ + "\"ERC20: ", + "mint to the zero address\"" + ], + [ + "te", + "ction" + ], + [ + "may ", + "use both the " + ], + [ + ";\\n }\\n ", + "uint256 " + ], + [ + "string,", + "string," + ], + [ + "{approve", + "}. " + ], + [ + "call to ", + "{approve}. " + ], + [ + "account (", + "an owner" + ], + [ + "remaining ", + "number of tokens that " + ], + [ + "granted ", + "exclusive " + ], + [ + "uni", + "code" + ], + [ + "specific ", + "function" + ], + [ + "desired ", + "value afterward" + ], + [ + "begin", + "n" + ], + [ + "Ownable is Context ", + "{\\n address private _owner" + ], + [ + "access control ", + "mechanism, " + ], + [ + "there is an ", + "account (an owner" + ], + [ + "allowance mechanism. ", + "`amount` is then deducted " + ], + [ + "that someone ", + "may use both the " + ], + [ + "transaction ordering. One possible solution", + " to mitig" + ], + [ + ") that can be ", + "granted exclusive " + ], + [ + "call to {approve}. ", + "`value` is the new allowance" + ], + [ + "access control mechanism, ", + "where" + ], + [ + "there is an account (an owner", + ") that can be granted exclusive " + ], + [ + "there is an account (an owner) that can be granted exclusive ", + "access " + ], + [ + "(", + ");\\n error " + ], + [ + "M", + "U" + ], + [ + "t", + "\\n * " + ], + [ + "` ", + "through " + ], + [ + "for ", + "more " + ], + [ + "value ", + "changes " + ], + [ + "are ", + "called" + ], + [ + "tim", + "es" + ], + [ + "action", + " " + ], + [ + "buy", + "DevFee" + ], + [ + "_mint", + "Amount" + ], + [ + ";\\r\\n", + "\\r\\n " + ], + [ + "receiver", + ", " + ], + [ + "temp", + " " + ], + [ + "on behalf of `owner", + "` through " + ], + [ + "remaining number of tokens that ", + "`spender` " + ], + [ + "desired value afterward", + "s:" + ], + [ + "value changes ", + "when " + ], + [ + "C", + "T" + ], + [ + "a", + "0" + ], + [ + "d", + "er of " + ], + [ + "spender", + " != address(0), \\\"ERC20: approve to " + ], + [ + "} ", + "are called" + ], + [ + "total", + "Fee" + ], + [ + ");\\n\\n ", + "uint256 " + ], + [ + ").", + "\\n *\\n * " + ], + [ + "id", + "s are " + ], + [ + "transferFrom", + "} are called" + ], + [ + "remain", + "der of " + ], + [ + "bool,", + "bool," + ], + [ + "assembly {", + "\\n // " + ], + [ + "less than ", + "3" + ], + [ + "comp", + "li" + ], + [ + "{transferFrom", + "}. This " + ], + [ + "old ", + "and the new allowance by unfortun" + ], + [ + "origin", + "al " + ], + [ + "Sets `amount` as the allowance of `spender` ", + "over " + ], + [ + "means", + "\\n * " + ], + [ + "ate this ", + "rac" + ], + [ + "H", + "A" + ], + [ + "_", + "stake" + ], + [ + "`", + ". This " + ], + [ + "n", + " " + ], + [ + "r", + "ate" + ], + [ + "un", + "less " + ], + [ + "se", + "qu" + ], + [ + "be ", + "changed " + ], + [ + "Balanc", + "es" + ], + [ + "address(0", + "x" + ], + [ + "can ", + "later " + ], + [ + "eth", + "Amount" + ], + [ + "_is", + "ApprovedOrOwner" + ], + [ + "interfaceId", + "`. " + ], + [ + ".org", + "/" + ], + [ + "addition", + "al" + ], + [ + "operation", + "s" + ], + [ + "stak", + "er" + ], + [ + "infin", + "ite " + ], + [ + "allowed to spend ", + "on behalf of `owner` through " + ], + [ + ", ", + "''" + ], + [ + "uint256", + ").max" + ], + [ + ". ", + "To " + ], + [ + "do", + "main" + ], + [ + "type(", + "uint256).max" + ], + [ + "Claim", + "ed" + ], + [ + "{approve} or {", + "transferFrom} are called" + ], + [ + "_B", + "URNED" + ], + [ + "checkpoint", + "s" + ], + [ + "(address spender, uint256 ", + "addedValue" + ], + [ + "10 ** ", + "2" + ], + [ + "ident", + "ified" + ], + [ + "necess", + "ari" + ], + [ + "Trac", + "ker" + ], + [ + "Contract module which ", + "provides a " + ], + [ + "(address sender", + ", address " + ], + [ + "basic ", + "access control mechanism, where" + ], + [ + "that someone may use both the ", + "old and the new allowance by unfortun" + ], + [ + "transaction ordering. One possible solution to mitig", + "ate this rac" + ], + [ + "value changes when ", + "{approve} or {transferFrom} are called" + ], + [ + "allowed to spend on behalf of `owner` through ", + "{transferFrom}. This " + ], + [ + "Contract module which provides a ", + "basic access control mechanism, where" + ], + [ + "that someone may use both the old and the new allowance by unfortun", + "ate" + ], + [ + "N", + "ot " + ], + [ + ", ", + "_msgSender()" + ], + [ + "can", + "'t " + ], + [ + "pres", + "ale" + ], + [ + ";\\n\\n // ", + "Token " + ], + [ + "OOOO", + "OOOO" + ], + [ + "with {", + "transferOwnership" + ], + [ + "token by either {approve} or {setApprovalForAll", + "}.\\n * - " + ], + [ + "Cumulative", + "Last" + ], + [ + "MIT ", + "licen" + ], + [ + "be changed ", + "with {transferOwnership" + ], + [ + "7", + "d" + ], + [ + "S", + "oftwa" + ], + [ + "th", + "ose " + ], + [ + ", ", + "etc" + ], + [ + "From", + "Target" + ], + [ + "add", + "ed to the " + ], + [ + "sender", + ",\\n address " + ], + [ + "IERC20", + " " + ], + [ + "struc", + "tu" + ], + [ + ").", + "div(" + ], + [ + "` is ", + "an " + ], + [ + ".\\n ", + "unchecked {\\n " + ], + [ + "account ", + "will be the " + ], + [ + "Po", + "si" + ], + [ + "\\n *\\n * ", + "Emits an {Approval" + ], + [ + "asset", + "s " + ], + [ + "RecoverError", + " " + ], + [ + "their ", + "use " + ], + [ + "your ", + "functions to " + ], + [ + "Counter ", + "storage " + ], + [ + "enti", + "re " + ], + [ + "math/", + "Math" + ], + [ + "`, which ", + "can be applied to " + ], + [ + "the owner ", + "account will be the " + ], + [ + "restrict ", + "their use " + ], + [ + "module is used through inheritance. It will make available ", + "the " + ], + [ + "`onlyOwner", + "`, which can be applied to " + ], + [ + "(int256 value", + ") internal pure returns (" + ], + [ + "By default, ", + "the owner account will be the " + ], + [ + "seaDrop", + "Impl" + ], + [ + "one that ", + "deploys the contract" + ], + [ + "can later ", + "be changed with {transferOwnership" + ], + [ + "your functions to ", + "restrict their use " + ], + [ + "`onlyOwner`, which can be applied to ", + "your functions to restrict their use " + ], + [ + "By default, the owner account will be the ", + "one that deploys the contract" + ], + [ + "By default, the owner account will be the one that deploys the contract", + ". Th" + ], + [ + "m", + "erkle " + ], + [ + "re", + "qui" + ], + [ + "re", + "fund " + ], + [ + "uint256", + "-}[`" + ], + [ + "` ", + "functions " + ], + [ + "\\n // ", + "the " + ], + [ + "remo", + "ved" + ], + [ + "Updat", + "ed(" + ], + [ + "\\n /// ", + "@param _" + ], + [ + "\"@openzeppelin/contracts/", + "utils/Context.sol\"" + ], + [ + "`]", + ", " + ], + [ + "fl", + "ash" + ], + [ + "We ", + "can " + ], + [ + "_red", + "is" + ], + [ + "ever", + "y " + ], + [ + "increaseAllowance", + "(address spender, uint256 addedValue" + ], + [ + "orac", + "lize" + ], + [ + "kee", + "p " + ], + [ + "=-", + "=-" + ], + [ + "ERC20PresetMinter", + "Pauser" + ], + [ + "D", + "et" + ], + [ + "con", + "s" + ], + [ + "li", + "ties" + ], + [ + "_max", + "TaxSwap" + ], + [ + "reserve", + "0" + ], + [ + "temp", + " = value" + ], + [ + "`tokenId` token ", + "is " + ], + [ + "the caller's ", + "account" + ], + [ + "_operatorApproval", + "s" + ], + [ + "mload(add(", + "signature" + ], + [ + "owner() == ", + "_msgSender(), \\\"Ownable: caller is not the owner" + ], + [ + " ", + "a " + ], + [ + "-", + "in" + ], + [ + "J", + "S" + ], + [ + "owner", + " != address(0), \\\"ERC20: approve " + ], + [ + "if", + "ic" + ], + [ + ") external ", + "onlyOwner " + ], + [ + "(uint256 ", + "amount" + ], + [ + "transferFrom", + "(\\n address from,\\n address to,\\n uint256 tokenId\\n " + ], + [ + "interface ", + "defined by\\n * `" + ], + [ + ", and ", + "it " + ], + [ + ",\\n * ", + "thereby " + ], + [ + "ECDSA", + "-" + ], + [ + "ob", + "ta" + ], + [ + "assembly {", + "\\n " + ], + [ + "assembly {", + "\\n " + ], + [ + "(token", + ", " + ], + [ + "(address target, bytes memory data", + ") internal returns (bytes memory) {\\n return " + ], + [ + "Hold", + "er" + ], + [ + "(address spender, uint256 ", + "subtractedValue" + ], + [ + "`account` ", + "had" + ], + [ + "Ethereum Signed ", + "Message" + ], + [ + "(uint256 a, uint256 b) internal pure returns (bool, ", + "uint256) {\\n " + ], + [ + "Renouncing ownership will leave the contract without an owner", + ",\\n * thereby " + ], + [ + "interface defined by\\n * `", + "interfaceId`. " + ], + [ + "0", + "9" + ], + [ + "]", + "(" + ], + [ + "de", + "red " + ], + [ + "To", + "Copy" + ], + [ + ");\\n", + "}\\n\\n" + ], + [ + "cre", + "ated " + ], + [ + "Mint", + "ed " + ], + [ + "using ", + "a " + ], + [ + "}.\\n */\\n function ", + "totalSupply() public view virtual override returns (" + ], + [ + "possibl", + "e: " + ], + [ + "represent", + "ing the " + ], + [ + "Over", + "load" + ], + [ + "at the ", + "end" + ], + [ + ") external;\\n\\n ", + "function " + ], + [ + "_initial", + "BuyTax" + ], + [ + "Grant", + "ed" + ], + [ + "uint8 v", + ",\\n bytes32 r,\\n bytes32 " + ], + [ + "abo", + "ve" + ], + [ + "update the ", + "allowance " + ], + [ + "Overflow not ", + "possible: " + ], + [ + "address) {\\n return _owner", + ";\\n }\\n\\n /**\\n * @dev " + ], + [ + "can later be changed with {transferOwnership", + "}." + ], + [ + ")", + ".\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function " + ], + [ + "} ", + "on " + ], + [ + "li", + "ed " + ], + [ + "\\n ", + "*" + ], + [ + ";\\n\\nimport \\\"", + "@openzeppelin/contracts/" + ], + [ + "\\n * `", + "onlyOwner" + ], + [ + "AccessControl", + ": " + ], + [ + " > 0", + ") {\\n " + ], + [ + "ves", + "ting" + ], + [ + "gas", + ".\\n */\\n function " + ], + [ + "token/ERC721/", + "IERC721" + ], + [ + ";\\n ", + "}\\n\\n function " + ], + [ + "this contract ", + "implements the " + ], + [ + "Returns true if ", + "this contract implements the " + ], + [ + "Can only be called by the current owner", + ".\\n */\\n function " + ], + [ + "burn from ", + "the zero address\"" + ], + [ + "invalid opcode to revert (consuming all remaining gas", + ").\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function " + ], + [ + "Throws if called by any account other than the owner", + ".\\n */\\n modifier " + ], + [ + "any functionality that is only available to the owner", + ".\\n */\\n function " + ], + [ + "Leaves the contract without owner. It will not be possible to call", + "\\n * `onlyOwner" + ], + [ + "#", + "how-" + ], + [ + "-", + "are" + ], + [ + "-", + "identified" + ], + [ + "i", + "eld" + ], + [ + "to", + "n" + ], + [ + "ti", + "tion" + ], + [ + "\\n *", + " " + ], + [ + "The ", + "address of the " + ], + [ + "transfer ", + "from the zero address\\\");\\n require(" + ], + [ + "safeTransferFrom", + "(\\n address from,\\n address to,\\n uint256 tokenId\\n " + ], + [ + "ing\\n * ", + "the " + ], + [ + "these ", + "ids are " + ], + [ + "requ", + "en" + ], + [ + "(bool success, ", + ") = " + ], + [ + "decreaseAllowance", + "(address spender, uint256 subtractedValue" + ], + [ + "standard ", + "as defined " + ], + [ + "interfaces", + "-are" + ], + [ + "how ", + "these ids are " + ], + [ + "Can only be called by the current owner", + ".\\n *\\n * NOTE: " + ], + [ + "https://eips.ethereum.org/EIPS/eip-165", + "#how-" + ], + [ + "-name", + "-" + ], + [ + "[EIP ", + "section" + ], + [ + "must use ", + "less than 3" + ], + [ + "EO", + "A" + ], + [ + "Throws if called by any account other than the owner.\\n */\\n modifier ", + "onlyOwner(" + ], + [ + "standard as defined ", + "in the EIP" + ], + [ + "interfaces-are", + "-identified" + ], + [ + "how these ids are ", + "created" + ], + [ + "Can only be called by the current owner.\\n *\\n * NOTE: ", + "Renouncing ownership will leave the contract without an owner,\\n * thereby " + ], + [ + "https://eips.ethereum.org/EIPS/eip-165#how-", + "interfaces-are-identified" + ], + [ + "(", + "e.g. " + ], + [ + ".", + "\\n /// @param " + ], + [ + "C", + "R" + ], + [ + "b", + "a" + ], + [ + "f", + "utu" + ], + [ + "l", + "ash" + ], + [ + "s ", + "any " + ], + [ + "en", + "able" + ], + [ + "de", + "posi" + ], + [ + ",\\n ", + "uint8 v,\\n bytes32 r,\\n bytes32 " + ], + [ + "index", + "es[" + ], + [ + " * ", + "(" + ], + [ + "per", + "iod" + ], + [ + ",\\n uint256 ", + "tokenId" + ], + [ + "number", + "Of" + ], + [ + "();\\n ", + "if (" + ], + [ + ");\\n\\n // ", + "Clear approval" + ], + [ + "immutable ", + "_" + ], + [ + "Remo", + "ve" + ], + [ + "fixed ", + "length" + ], + [ + "Moves `amount` tokens from ", + "the caller's account" + ], + [ + "abo", + "ve " + ], + [ + "Af", + "ter" + ], + [ + "merkle", + "Root" + ], + [ + "want", + " to " + ], + [ + "to learn more about ", + "how these ids are created" + ], + [ + "transferOwnership(address newOwner) public virtual ", + "onlyOwner {\\n require(" + ], + [ + "st", + "ep" + ], + [ + "li", + "es " + ], + [ + "temp", + " != 0) {\\n " + ], + [ + "_N", + "EXT_INITIALIZED" + ], + [ + "OU", + "NT" + ], + [ + "dividing ", + "two unsigned integ" + ], + [ + "iszero", + "(" + ], + [ + "_AU", + "X" + ], + [ + ";\\n while (", + "temp != 0) {\\n " + ], + [ + "address of the current owner", + ".\\n */\\n function " + ], + [ + "remainder of ", + "dividing two unsigned integ" + ], + [ + "(", + "string memory " + ], + [ + "O", + "(1" + ], + [ + "]", + ";\\n }\\n\\n /**\\n * @dev See {IERC721-" + ], + [ + "j", + "s" + ], + [ + "\\n * ", + "there is an account (an owner) that can be granted exclusive access " + ], + [ + "s the ", + "`" + ], + [ + "ot", + "e" + ], + [ + "Allowanc", + "e(" + ], + [ + ";\\n ", + "address public " + ], + [ + "If ", + "`account` had" + ], + [ + "Au", + "to" + ], + [ + "}\\r\\n", + "\\r\\n" + ], + [ + "_initial", + "SellTax" + ], + [ + "to\\n * ", + "specific function" + ], + [ + "day", + "s" + ], + [ + "_approve(owner, spender, ", + "currentAllowance " + ], + [ + ";\\n\\n // The bit ", + "position" + ], + [ + "\"// SPDX-License-Identifier: G", + "PL-3.0" + ], + [ + "JS", + "ON" + ], + [ + "any functionality that is only available to the owner.\\n */\\n function ", + "renounceOwnership() public virtual onlyOwner {\\n " + ], + [ + "\\n * there is an account (an owner) that can be granted exclusive access ", + "to\\n * specific function" + ], + [ + "S", + "pl" + ], + [ + "`", + ".\\n *\\n * Requirements:\\n *\\n * - " + ], + [ + "i", + "k" + ], + [ + "w", + "ard " + ], + [ + "it", + "ter" + ], + [ + "from", + "Balance" + ], + [ + "dev", + "elopment" + ], + [ + "con", + "fl" + ], + [ + "bytes32", + ") {\\n return " + ], + [ + "burn", + "ed " + ], + [ + "sign", + "ific" + ], + [ + ";\\n\\n ", + "/// @notice " + ], + [ + "0x", + "00" + ], + [ + "bool ", + "success" + ], + [ + ");\\n\\n /**\\n * @dev ", + "Initializes the contract setting the deployer as the initial owner" + ], + [ + "ID", + " of the token" + ], + [ + "ed in ", + "a " + ], + [ + "_T", + "IME" + ], + [ + "_get", + "Rate" + ], + [ + "ecaus", + "e the " + ], + [ + "Do", + "mainSeparator" + ], + [ + "bpt", + "Amount" + ], + [ + ";\\n\\n event ", + "OwnershipTransferred(address indexed previousOwner, address indexed newOwner" + ], + [ + "Librar", + "y" + ], + [ + "\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific function", + "s.\\n *\\n * " + ], + [ + "_", + "sell" + ], + [ + "a", + "wa" + ], + [ + "re", + "veal" + ], + [ + "\\\"", + ";\\n }\\n uint256 " + ], + [ + "00", + "0 " + ], + [ + " ", + " " + ], + [ + "s.", + "html#" + ], + [ + "and", + "/" + ], + [ + "not", + "e " + ], + [ + "(uint256 a, uint256 b", + ", string memory errorMessage" + ], + [ + "Query", + "able" + ], + [ + "erc20", + "-" + ], + [ + "throw", + "Error" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * ", + "Can only be called by the current owner.\\n */\\n function " + ], + [ + "newOwner != address(0), \\\"Ownable: new owner is the zero address", + "\\\");\\n " + ], + [ + "(address sender, address ", + "recipient, uint256 amount" + ], + [ + " ", + "in the " + ], + [ + "C", + " " + ], + [ + "b", + "b" + ], + [ + "g", + "o " + ], + [ + "h", + "si" + ], + [ + "th", + "us " + ], + [ + "to ", + "!= " + ], + [ + "byt", + "e" + ], + [ + "Total", + "Supply" + ], + [ + " <", + "0.8.0" + ], + [ + "++", + "i" + ], + [ + ".\\n *\\n * This ", + "function call " + ], + [ + "████", + "████" + ], + [ + "See the ", + "corresponding\\n * " + ], + [ + "``role``'s ", + "admin role" + ], + [ + "interface defined by\\n * `interfaceId`. ", + "See the corresponding\\n * " + ], + [ + "Returns true if this contract implements the ", + "interface defined by\\n * `interfaceId`. See the corresponding\\n * " + ], + [ + "to learn more about how these ids are created", + ".\\n *\\n * This function call " + ], + [ + "to learn more about how these ids are created.\\n *\\n * This function call ", + "must use less than 3" + ], + [ + "1", + "36" + ], + [ + "00", + " " + ], + [ + "onlyOwner", + " {\\n " + ], + [ + "remo", + "ving " + ], + [ + "\\u0027", + "s " + ], + [ + "comp", + "il" + ], + [ + "rounded ", + "down" + ], + [ + "bene", + "fici" + ], + [ + "(x, ", + "y, " + ], + [ + "burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _", + "beforeTokenTransfer" + ], + [ + "Does not ", + "update the allowance " + ], + [ + "condition is to first reduce the spender", + "'s " + ], + [ + "confl", + "ict " + ], + [ + " ", + "@dev " + ], + [ + "C", + "ap" + ], + [ + "F", + "ilter" + ], + [ + "G", + "et" + ], + [ + "R", + "AT" + ], + [ + ");", + " // " + ], + [ + "is ", + "discourag" + ], + [ + ".sol\\\"", + ";\\r\\n" + ], + [ + "if (value ", + "== 0) {\\n return " + ], + [ + "LO", + "W" + ], + [ + "to\\n * ", + "the owner" + ], + [ + "} from \\\"", + "./" + ], + [ + "mapping(address => uint256) private ", + "_balances" + ], + [ + "there are ", + "no " + ], + [ + "`account`.\\n *\\n * ", + "If `account` had" + ], + [ + "modifier\\n * ", + "`onlyOwner`, which can be applied to your functions to restrict their use " + ], + [ + "Reser", + "ves" + ], + [ + "++;\\n ", + "temp " + ], + [ + "maximum `", + "uint256" + ], + [ + "Contract module which provides a basic access control mechanism, where", + "\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * " + ], + [ + "module is used through inheritance. It will make available the ", + "modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use " + ], + [ + "temp = value", + ";\\n uint256 " + ], + [ + "\\\";\\n }\\n uint256 ", + "temp = value;\\n uint256 " + ], + [ + "condition is to first reduce the spender's ", + "allowance to 0 and set " + ], + [ + "module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use ", + "to\\n * the owner" + ], + [ + "\"", + "Transfer " + ], + [ + "1", + "; " + ], + [ + "N", + "ft" + ], + [ + ", ", + "usually " + ], + [ + "dat", + "e" + ], + [ + " to ", + "prevent " + ], + [ + " of the ", + "contract" + ], + [ + "amount ", + "must be greater than " + ], + [ + "est ", + "way to " + ], + [ + "reserve", + "In" + ], + [ + "_address", + "Data" + ], + [ + "caller is not ", + "owner nor " + ], + [ + "at the ", + "beginn" + ], + [ + "MINT", + "ED" + ], + [ + "Fee ", + "= _" + ], + [ + "OperatorFilter", + "Registry" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n\\n", + "pragma solidity >=" + ], + [ + "des", + "tin" + ], + [ + "By default, the owner account will be the one that deploys the contract. Th", + "is\\n * " + ], + [ + "transferOwnership(address newOwner) public virtual onlyOwner {\\n require(", + "newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n " + ], + [ + "P", + "enalty" + ], + [ + "U", + "SD" + ], + [ + "address ", + "data" + ], + [ + "\\n *", + "\\r\\n * " + ], + [ + "\"ERC20: ", + "burn from the zero address\"" + ], + [ + "\\\\x", + "19" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Returns the ", + "number of " + ], + [ + "}\\n * ", + "event" + ], + [ + "Interface of the ERC20 ", + "standard as defined in the EIP" + ], + [ + "Sets `amount` as the allowance of `spender` over ", + "the caller's " + ], + [ + ";\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner", + ");\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner" + ], + [ + "m", + "m" + ], + [ + "Amount", + " " + ], + [ + "ck", + "et" + ], + [ + "as ", + "it " + ], + [ + "must ", + "be\\n * " + ], + [ + ",\\n uint256 ", + "quantity" + ], + [ + "point", + "er " + ], + [ + "For example", + ", " + ], + [ + "al representation.\\n */\\n function ", + "toHexString" + ], + [ + "Pos", + "++" + ], + [ + "_", + "LENGTH" + ], + [ + "r", + "` and `" + ], + [ + "res", + "er" + ], + [ + "ev", + "en " + ], + [ + ";\\n ", + "} else {" + ], + [ + "Con", + "secuti" + ], + [ + "SellTax", + "At" + ], + [ + "detail", + "s." + ], + [ + "\\n *\\n * This ", + "module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner" + ], + [ + "leaves", + "L" + ], + [ + "startTokenId, ", + "quantity" + ], + [ + "aff", + "ect" + ], + [ + "2", + "32" + ], + [ + "F", + "ound" + ], + [ + "[", + "i" + ], + [ + "]", + ".\\n */\\n function " + ], + [ + "c", + "alc" + ], + [ + "s", + "aid " + ], + [ + "t", + "reasury" + ], + [ + ", ", + "Rounding rounding" + ], + [ + "uint256", + "[] memory" + ], + [ + "from", + "` must have a balance of at least `amount" + ], + [ + "s, ", + "etc" + ], + [ + "vent", + "ion" + ], + [ + "_in", + "itializ" + ], + [ + "mod ", + "2^256" + ], + [ + "alway", + "s " + ], + [ + "owner() public view virtual returns (", + "address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev " + ], + [ + "plat", + "form" + ], + [ + "can later be changed with {transferOwnership}.", + "\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner" + ], + [ + "Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * ", + "By default, the owner account will be the one that deploys the contract. This\\n * " + ], + [ + "Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * ", + "can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner" + ], + [ + "in", + "fo" + ], + [ + "in", + "vok" + ], + [ + "co", + "re" + ], + [ + "tokens", + ".\\n *\\n * " + ], + [ + "See {", + "IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual " + ], + [ + "\"// SPDX-License-Identifier: MIT\\n", + "pragma solidity ^0.8." + ], + [ + "Fin", + "ally, " + ], + [ + "_dev", + "elopment" + ], + [ + "openzeppelin-contracts/", + "contracts/" + ], + [ + "VAL", + "ID" + ], + [ + "assign", + "s " + ], + [ + "Creates ", + "`amount` " + ], + [ + "don", + "'t " + ], + [ + "_", + "values" + ], + [ + "m", + "ixed" + ], + [ + "remove", + "Limits" + ], + [ + "Exact", + "Tokens" + ], + [ + "(value", + ", " + ], + [ + ");\\r\\n }\\r\\n", + "\\r\\n /**\\r\\n * @dev " + ], + [ + "bots", + "_" + ], + [ + "fund", + "s " + ], + [ + "Storage", + "Slot" + ], + [ + "Join", + "Exit" + ], + [ + ") internal virtual {}\\n\\n /**\\n * @dev ", + "Hook that is called after " + ], + [ + "STA", + "MP" + ], + [ + "forever", + " " + ], + [ + "_STAR", + "T" + ], + [ + "-name-", + "mixed" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function ", + "transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n " + ], + [ + " ", + "P" + ], + [ + "s", + "mart " + ], + [ + "add", + "ed to " + ], + [ + "Ownership", + "Data" + ], + [ + ",\\n uint256 ", + "_" + ], + [ + "dst", + "ChainId" + ], + [ + "(bytes32 ", + "role" + ], + [ + "Packed", + "(\\\"" + ], + [ + "By", + "Index" + ], + [ + "_reduce", + "SellTaxAt" + ], + [ + " is Context", + ", IERC20" + ], + [ + ";\\n emit Approval(owner, ", + "spender, amount" + ], + [ + "Consecuti", + "ve" + ], + [ + "(", + ");\\n " + ], + [ + "T", + "ick" + ], + [ + "U", + "L" + ], + [ + "U", + "int256" + ], + [ + ") ", + ": " + ], + [ + "a ", + "== " + ], + [ + "` ", + "tokens " + ], + [ + "re ", + "of the " + ], + [ + "code", + "hash" + ], + [ + "fee", + "Amount" + ], + [ + "the caller must have ", + "a balance of at least `amount" + ], + [ + "to\\n * ", + "another (`to" + ], + [ + ") {\\n value /= ", + "10**" + ], + [ + ";\\n }\\n if (value >= ", + "10**" + ], + [ + "\"ERC20: burn ", + "amount exceeds balance\"" + ], + [ + "sender,\\n address ", + "recipient" + ], + [ + "address of the current owner.\\n */\\n function ", + "owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev " + ], + [ + "and/", + "or " + ], + [ + "9", + "4" + ], + [ + "`", + "_" + ], + [ + "a", + " * " + ], + [ + "un", + "lock" + ], + [ + "address ", + "oldOwner" + ], + [ + "lo", + "s" + ], + [ + ".\\n *\\n * ", + "If " + ], + [ + "Of", + "(" + ], + [ + "Str", + "ing " + ], + [ + "using ", + "the\\n * " + ], + [ + "int256", + ", " + ], + [ + "_tax", + "SwapThreshold" + ], + [ + "`.\\n *\\n * ", + "Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function " + ], + [ + "registr", + "y " + ], + [ + "owned by ", + "`account`.\\n */\\n function " + ], + [ + "at least ", + "`amount` " + ], + [ + "NOTE: ", + "This " + ], + [ + "off", + "set" + ], + [ + "address(this).", + "balance" + ], + [ + "Sets `amount` as the allowance of `spender` ", + "over the " + ], + [ + "Ownable is Context {\\n address private _owner", + ";\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner" + ], + [ + "at the beginn", + "ing of " + ], + [ + "to\\n * another (`to", + "`).\\n *\\n * " + ], + [ + "owned by `account`.\\n */\\n function ", + "balanceOf(address account" + ], + [ + "(", + ");\\nerror " + ], + [ + "b", + "5" + ], + [ + "\\n", + "\\n " + ], + [ + "res", + "et" + ], + [ + ", ", + "see " + ], + [ + "amount", + ", \\\"ERC20: " + ], + [ + "a ", + "short" + ], + [ + "sp", + "i" + ], + [ + ".\\n */\\n function ", + "allowance(address owner, address spender" + ], + [ + "allowanc", + "es for " + ], + [ + "event", + "s" + ], + [ + "bytes32 ", + "private " + ], + [ + "encode", + "Packed" + ], + [ + "balance ", + "of `" + ], + [ + "1 ", + ": 0" + ], + [ + "((", + "((" + ], + [ + "less than ", + "smallest " + ], + [ + "oldOwner", + ", newOwner" + ], + [ + "dividing ", + "by " + ], + [ + "Code", + "Hash" + ], + [ + "currentAllowance = ", + "allowance(owner, spender" + ], + [ + ".\\n */\\n event Transfer(address indexed from, address indexed to, uint256 ", + "value" + ], + [ + "See {IERC20-", + "approve}." + ], + [ + "Note that `value` may be zero", + ".\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value" + ], + [ + "`value` tokens are moved from one account (`from`) ", + "to\\n * another (`to`).\\n *\\n * " + ], + [ + "allowance of a `spender` for an `owner` is set by", + "\\n * a " + ], + [ + "Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner", + ".\\n */\\nabstract contract " + ], + [ + "`value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * ", + "Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value" + ], + [ + "_", + "ID" + ], + [ + "su", + "cc" + ], + [ + "value", + "s for " + ], + [ + ".\\n */\\n function ", + "update" + ], + [ + "sub", + "system" + ], + [ + "error", + " == " + ], + [ + "Mint", + "able" + ], + [ + "decimals", + "` " + ], + [ + "result ", + ":= " + ], + [ + "src", + "ChainId" + ], + [ + "tra", + "it" + ], + [ + "We ", + "have " + ], + [ + "Lock", + "ed" + ], + [ + "internal function is equivalent to ", + "`approve" + ], + [ + "(address registrant", + ", address " + ], + [ + "certain ", + "subsystem" + ], + [ + "in existence", + ".\\n */\\n function totalSupply() external view returns (uint256" + ], + [ + "OwnershipTransferred(", + "oldOwner, newOwner" + ], + [ + "eq", + "(" + ], + [ + ");\\n\\n /**\\n * @dev Emitted when the ", + "allowance of a `spender` for an `owner` is set by\\n * a " + ], + [ + "Fixed", + "Point" + ], + [ + ". See the ", + "note " + ], + [ + "_allowances[owner][spender] = amount", + ";\\n emit Approval(owner, spender, amount" + ], + [ + "address oldOwner", + " = _owner" + ], + [ + "allowances for ", + "certain subsystem" + ], + [ + "`value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value", + ");\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a " + ], + [ + "internal function is equivalent to `approve", + "`, and " + ], + [ + ". See the note ", + "at the beginning of " + ], + [ + "allowances for certain subsystem", + "s, etc" + ], + [ + " ", + "to" + ], + [ + "'", + "t" + ], + [ + "C", + "H" + ], + [ + "j", + "oin" + ], + [ + "v", + "0.5." + ], + [ + "uint256 ", + "ID of the token" + ], + [ + "of ", + "these " + ], + [ + "(address ", + "payable " + ], + [ + "ation", + ".\\n *\\n * " + ], + [ + ");\\n }\\n\\n /**\\n * @dev ", + "Converts a `uint256` to its ASCII `string` hexadecim" + ], + [ + "0x", + "20" + ], + [ + "the call", + "er of " + ], + [ + ".\\n */\\n function _", + "burn" + ], + [ + "set ", + "automatic " + ], + [ + ",\\n ", + "uint256 " + ], + [ + ".\\n ", + "if (" + ], + [ + "present", + ".\\n */\\n function " + ], + [ + "safeTransferFrom", + "} " + ], + [ + "was ", + "successful" + ], + [ + "defin", + "ed in " + ], + [ + "? ", + "1 : 0" + ], + [ + "BITPOS", + "_EXTRA_DATA" + ], + [ + "maxWallet", + "Size" + ], + [ + "seri", + "es" + ], + [ + "required by the ", + "EIP" + ], + [ + "awa", + "re of the " + ], + [ + "using the\\n * ", + "allowance mechanism. `amount` is then deducted " + ], + [ + "in existence.\\n */\\n function totalSupply() external view returns (uint256", + ");\\n\\n /**\\n * @dev Returns the amount of tokens " + ], + [ + "`value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a ", + "call to {approve}. `value` is the new allowance" + ], + [ + "set automatic ", + "allowances for certain subsystems, etc" + ], + [ + "d", + "d" + ], + [ + "\\n * ", + "https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729" + ], + [ + "from", + "Block" + ], + [ + "ing ", + "mechanisms" + ], + [ + "of ", + "contract " + ], + [ + "require", + "d" + ], + [ + "token ", + "fees" + ], + [ + "s[", + "i" + ], + [ + "pack", + "OwnershipData" + ], + [ + "next", + "ExtraData" + ], + [ + "must have ", + "allowance for " + ], + [ + "implementation", + " is " + ], + [ + "approval", + "s" + ], + [ + "RA", + "X" + ], + [ + ", s", + "lash" + ], + [ + "solidity", + "-utils/" + ], + [ + "(address(0), to, ", + "startTokenId, quantity" + ], + [ + "78", + "9" + ], + [ + "automatic ", + "token fees" + ], + [ + "transfer}", + ", and " + ], + [ + "\\\\xe3\\\\x8", + "1" + ], + [ + "internal function is equivalent to {", + "transfer}, and " + ], + [ + "desired value afterwards:", + "\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729" + ], + [ + "tokens.\\n *\\n * ", + "Returns a boolean value indicating whether the operation succeeded" + ], + [ + "owned by `account`.\\n */\\n function balanceOf(address account", + ") external view returns (uint256);\\n\\n /**\\n * @dev " + ], + [ + ". See the note at the beginning of ", + "{ERC20" + ], + [ + "required by the EIP", + ". See the note at the beginning of {ERC20" + ], + [ + "ing mechanisms", + ", etc" + ], + [ + ", slash", + "ing mechanisms, etc" + ], + [ + "automatic token fees", + ", slashing mechanisms, etc" + ], + [ + "(", + "bytes" + ], + [ + "-", + "R" + ], + [ + "1", + "00000000" + ], + [ + "\\", + "tu" + ], + [ + "j", + "ust " + ], + [ + "= ", + "true" + ], + [ + "address ", + "is " + ], + [ + "bool", + ") {\\n return " + ], + [ + "ul", + "ner" + ], + [ + ".\\n *\\n * ", + "`" + ], + [ + ".\\n *\\n * ", + "Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function " + ], + [ + ", p", + "lease " + ], + [ + "set ", + "once " + ], + [ + " {\\n ", + "using " + ], + [ + "marketing", + "Fee" + ], + [ + "spender` ", + "must have allowance for " + ], + [ + ">> ", + "_" + ], + [ + ");\\n\\n /**\\n * @dev Returns the ", + "remaining number of tokens that `spender` " + ], + [ + "implement ", + "automatic token fees, slashing mechanisms, etc" + ], + [ + "cr", + "v" + ], + [ + "is\\n * ", + "zero by default" + ], + [ + "Default", + "Royalty" + ], + [ + "low ", + "level " + ], + [ + "any", + "more" + ], + [ + "rang", + "e" + ], + [ + "ONE_", + "20" + ], + [ + "set._inner, ", + "bytes32" + ], + [ + "malle", + "able " + ], + [ + "(\\n address owner,\\n address spender", + ",\\n uint256 amount\\n " + ], + [ + "CAUTION", + ": " + ], + [ + "in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens ", + "owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev " + ], + [ + ".\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function ", + "transferFrom" + ], + [ + "spender` must have allowance for ", + "the caller of " + ], + [ + ");\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` ", + "will be\\n * " + ], + [ + "is\\n * zero by default", + ".\\n *\\n * This " + ], + [ + "(", + "0, " + ], + [ + ".", + "\\r\\n " + ], + [ + "I", + "O" + ], + [ + "v", + "ulner" + ], + [ + "uint256", + ") private " + ], + [ + "\\n * ", + "transaction ordering. One possible solution to mitigate this rac" + ], + [ + "\\n * ", + "that someone may use both the old and the new allowance by unfortunate" + ], + [ + "pp", + "ed" + ], + [ + "con", + "vention" + ], + [ + "s.", + "\\n */\\nlibrary " + ], + [ + "(\\n address ", + "indexed " + ], + [ + ");\\n\\n /**\\n * @dev ", + "Moves `amount` tokens from " + ], + [ + "uint256) {\\n return ", + "_totalSupply" + ], + [ + "the\\n * ", + "desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729" + ], + [ + "reserve", + "Out" + ], + [ + "Param", + "s" + ], + [ + "tokens and ", + "assigns " + ], + [ + "secon", + "d" + ], + [ + "string(abi.encode", + "Packed(" + ], + [ + "Beware that changing an allowance with this method brings the risk", + "\\n * that someone may use both the old and the new allowance by unfortunate" + ], + [ + "allowed to spend on behalf of `owner` through {transferFrom}. This ", + "is\\n * zero by default.\\n *\\n * This " + ], + [ + ");\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * ", + "allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This " + ], + [ + "\\n * transaction ordering. One possible solution to mitigate this rac", + "e\\n * " + ], + [ + "Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate", + "\\n * transaction ordering. One possible solution to mitigate this race\\n * " + ], + [ + "(", + "from" + ], + [ + "]", + ";\\n }\\n\\n /**\\n * @dev " + ], + [ + "f", + "ac" + ], + [ + "{\\n ", + "uint256 " + ], + [ + "value ", + "== 0" + ], + [ + ") public ", + "onlyOwner {\\n " + ], + [ + "Fees", + "[" + ], + [ + "raw", + "Amount" + ], + [ + "And", + "Call" + ], + [ + "arg", + "ument" + ], + [ + "set._", + "values" + ], + [ + "$$", + "$$" + ], + [ + "Pri", + "vat" + ], + [ + ".\\n *\\n * IMPORTANT: ", + "Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * " + ], + [ + "TypedData", + "V4" + ], + [ + "Enabl", + "ed = " + ], + [ + "approve(address spender, uint256 amount) external returns (bool", + ");\\n\\n /**\\n * @dev Moves `amount` tokens from " + ], + [ + "upd", + "Ad" + ], + [ + "value changes when {approve} or {transferFrom} are called", + ".\\n */\\n function allowance(address owner, address spender" + ], + [ + "\\n *\\n * Emits an {Approval", + "} event.\\n */\\n function " + ], + [ + "tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded", + ".\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * " + ], + [ + "spender` must have allowance for the caller of ", + "at least" + ], + [ + "the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729", + "\\n *\\n * Emits an {Approval} event.\\n */\\n function " + ], + [ + ");\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This ", + "value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender" + ], + [ + "-", + "encod" + ], + [ + "d", + "y" + ], + [ + "{", + "\\n " + ], + [ + "int", + "128" + ], + [ + "//", + "\\n // " + ], + [ + "it", + "'s " + ], + [ + "\\\"", + ";\\n " + ], + [ + "Token", + "To" + ], + [ + "token ", + "transfer" + ], + [ + "== ", + "false" + ], + [ + "Swap", + "FeePercentage" + ], + [ + "the call", + " " + ], + [ + "isApprovedForAll", + "(owner, " + ], + [ + "\"Address: ", + "insufficient " + ], + [ + "}.\\n *\\n * ", + "NOTE: " + ], + [ + ");\\n }", + "\\n }\\n\\n " + ], + [ + "Revok", + "es " + ], + [ + "34", + "56" + ], + [ + ".\\n */\\n event Approval(address indexed owner, address indexed ", + "spender, uint256 value" + ], + [ + "neg", + "ative" + ], + [ + "_TIME", + "STAMP" + ], + [ + "tokens and assigns ", + "them to " + ], + [ + "the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function ", + "approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from " + ], + [ + "/", + "=lib/" + ], + [ + "3", + " " + ], + [ + "I", + "GN" + ], + [ + "ed ", + "for " + ], + [ + "er ", + "version of " + ], + [ + ") internal ", + "returns (bool) {\\n return _" + ], + [ + "` to ", + "transfer " + ], + [ + "Paus", + "ed " + ], + [ + "has ", + "an " + ], + [ + "get ", + "its " + ], + [ + "tokenId ", + "uint256 ID of the token" + ], + [ + "(bytes32 ", + "hash" + ], + [ + ") external returns (bool", + ");\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender" + ], + [ + ", \\\"ERC20: ", + "decreased allowance below zero" + ], + [ + "` must have ", + "at least `amount` " + ], + [ + "`account`, ", + "increas" + ], + [ + "ZZZZZZZZ", + "ZZZZZZZZ" + ], + [ + "NSF", + "ER_" + ], + [ + "bitr", + "ary " + ], + [ + "Creates `amount` ", + "tokens and assigns them to " + ], + [ + "`value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance", + ".\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value" + ], + [ + "`", + "\\n * - `" + ], + [ + "a ", + "new " + ], + [ + " = ", + "_msgSender(" + ], + [ + "for ", + "each " + ], + [ + "12", + "3456" + ], + [ + "itel", + "ist " + ], + [ + "⣿⣿", + "⣿⣿" + ], + [ + "that", + "\\n * " + ], + [ + "nCheckpoint", + "s" + ], + [ + "a - ", + "b" + ], + [ + "Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract ", + "Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner" + ], + [ + "Creates `amount` tokens and assigns them to ", + "`account`, increas" + ], + [ + " ", + "OPERATIONS\\n // =============================================================\\n\\n /**\\n * @dev " + ], + [ + "2", + ");\\n " + ], + [ + "R", + "ate " + ], + [ + "_", + "liquidity" + ], + [ + "s ", + "can call " + ], + [ + "at", + "tack" + ], + [ + "ex", + "it" + ], + [ + " to ", + "another " + ], + [ + "log", + "Bytes" + ], + [ + "Tim", + "e " + ], + [ + "dig", + "est" + ], + [ + "EN", + "D" + ], + [ + "symbol of the token", + ", usually " + ], + [ + "` functions ", + "anymore" + ], + [ + "123456", + "789" + ], + [ + "symbol of the token, usually ", + "a short" + ], + [ + "` functions anymore", + ". " + ], + [ + "3", + "d" + ], + [ + "S", + "p" + ], + [ + "l", + "ic" + ], + [ + "n", + "ess " + ], + [ + "n", + "'t" + ], + [ + "in", + "d " + ], + [ + "or", + "(" + ], + [ + "Re", + "veal" + ], + [ + "require", + "s " + ], + [ + "burn", + "ed by " + ], + [ + ".length", + " == " + ], + [ + "subtractedValue", + ", \\\"ERC20: decreased allowance below zero" + ], + [ + ") {\\n require(", + "value <= type(" + ], + [ + "uint256, ", + "reverting on\\n * overflow (when the input is " + ], + [ + "decimals ", + "used to " + ], + [ + "abc", + "def" + ], + [ + ") external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender", + ") external view returns (uint256);\\n\\n /**\\n * @dev " + ], + [ + "uint256, reverting on\\n * overflow (when the input is ", + "greater than largest " + ], + [ + "O", + "l" + ], + [ + "k", + "k" + ], + [ + "in", + "side " + ], + [ + "is", + "Ex" + ], + [ + "\\\"", + ");\\r\\n\\r\\n " + ], + [ + "Re", + "plac" + ], + [ + "li", + "er" + ], + [ + "value ", + "to be " + ], + [ + "All", + "Fee" + ], + [ + " is ", + "emitted " + ], + [ + "eth", + "el" + ], + [ + "non", + "ethel" + ], + [ + "Swap", + "AndLiquify" + ], + [ + "gener", + "al " + ], + [ + "Us", + "age of " + ], + [ + "`role", + "` from " + ], + [ + "utils/Context", + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev " + ], + [ + "detail", + "ed " + ], + [ + "\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0", + ";\\n\\n/**\\n * @dev " + ], + [ + "[to", + "]" + ], + [ + "behavior ", + "is " + ], + [ + "operator, ", + "approved" + ], + [ + "voting pow", + "er " + ], + [ + " @dev ", + "Creates `amount` tokens and assigns them to `account`, increas" + ], + [ + "spi", + "red by " + ], + [ + "Revokes ", + "`role` from " + ], + [ + "symbol of the token, usually a short", + "er version of " + ], + [ + "(", + "Counter storage " + ], + [ + "B", + "ase " + ], + [ + "`", + "tokenId" + ], + [ + "w", + "rapp" + ], + [ + "to", + "Mask" + ], + [ + "in", + "crease" + ], + [ + ": ", + "they " + ], + [ + "mem", + "ber " + ], + [ + "that ", + "contract recipient" + ], + [ + ") external view returns (", + "uint256 " + ], + [ + ";\\n ", + " " + ], + [ + "abi.encode", + "WithSelector" + ], + [ + "OpenZe", + "ppelin" + ], + [ + "has ", + "to be " + ], + [ + "an {Approval", + "} event" + ], + [ + "`. ", + "A" + ], + [ + "tokens from ", + "being " + ], + [ + "_msgSender()", + "][spender" + ], + [ + "first ", + "that contract recipient" + ], + [ + "downcast", + "ed" + ], + [ + "user ", + "representation" + ], + [ + "ERC721 ", + "protocol" + ], + [ + ") internal virtual {", + "}\\n}\\n\"" + ], + [ + "Day", + "s" + ], + [ + ") external view returns (bool", + ");\\n}\\n\"" + ], + [ + "from the zero address\\\");\\n require(", + "spender != address(0), \\\"ERC20: approve to " + ], + [ + "_allowances[", + "_msgSender()][spender" + ], + [ + "ed to a ", + "user " + ], + [ + "well", + "-" + ], + [ + "removed ", + "from the " + ], + [ + "checking ", + "first that contract recipient" + ], + [ + "ECDSA: invalid ", + "signature " + ], + [ + "owner != address(0), \\\"ERC20: approve ", + "from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to " + ], + [ + ",\\n uint8 v,\\n bytes32 r,\\n bytes32 ", + "s\\n " + ], + [ + "forever ", + "locked" + ], + [ + "aware of the ", + "ERC721 protocol" + ], + [ + "get its ", + "user representation" + ], + [ + "decimals used to ", + "get its user representation" + ], + [ + "(Counter storage ", + "counter" + ], + [ + "tokens from being ", + "forever locked" + ], + [ + " ", + "it" + ], + [ + "6", + "6" + ], + [ + "X", + "96" + ], + [ + "tr", + "ading " + ], + [ + "\\n ", + "inverse *= 2 - denominator * inverse; // inverse mod 2^" + ], + [ + "is", + "n't " + ], + [ + "ar", + "di" + ], + [ + "In", + " " + ], + [ + "sender", + "` must have a balance of at least `amount" + ], + [ + "Si", + "gner" + ], + [ + "amount ", + "<= " + ], + [ + "s\\n * ", + "are " + ], + [ + "mak", + "e the " + ], + [ + "unchecked {", + "\\n " + ], + [ + ")\\n", + "\\n // " + ], + [ + "{\\n /**\\n * @dev ", + "Returns true if " + ], + [ + "1", + ",\\n " + ], + [ + "5", + "` (`" + ], + [ + "S", + "um" + ], + [ + "_", + "display" + ], + [ + "a", + "it" + ], + [ + "c", + "are " + ], + [ + "**", + "*" + ], + [ + "a ", + "balance of `" + ], + [ + "account", + "` must have at least `amount` " + ], + [ + "be ", + "display" + ], + [ + "event", + "s, " + ], + [ + "@@", + "@" + ], + [ + "Address", + ", " + ], + [ + "burn", + "(uint256 tokenId" + ], + [ + "`, ", + "a balance of `" + ], + [ + "returndata", + ";\\n } else {" + ], + [ + "initial", + "izer" + ], + [ + "_ ", + "purpos" + ], + [ + ".\\r\\n *\\r\\n * ", + "Requirements:\\r\\n *\\r" + ], + [ + "es: ", + "it " + ], + [ + "equal", + "s `" + ], + [ + "\\n\\t *", + " " + ], + [ + "information", + " is only " + ], + [ + "used for ", + "_display" + ], + [ + "if `", + "decimals` " + ], + [ + "arithmetic", + " of the contract" + ], + [ + "For example, ", + "if `decimals` " + ], + [ + "` tokens ", + "should" + ], + [ + "ed to a user ", + "as `" + ], + [ + "be display", + "ed to a user as `" + ], + [ + "_ purpos", + "es: it " + ], + [ + "information is only ", + "used for _display" + ], + [ + "For example, if `decimals` ", + "equals `" + ], + [ + "information is only used for _display", + "_ purposes: it " + ], + [ + "e", + "9" + ], + [ + "s", + ").\\n *\\n * " + ], + [ + "\\n ", + ") internal {\\n " + ], + [ + "t ", + "for a " + ], + [ + ");\\n\\n ", + "event " + ], + [ + "of the ", + "arithmetic of the contract" + ], + [ + ".\\n *\\n * Emits ", + "an {" + ], + [ + "ERC721A", + " " + ], + [ + "gas ", + "cost" + ], + [ + "no ", + "way " + ], + [ + ") internal pure returns (uint256) {\\n ", + "uint256 result = " + ], + [ + "modifier ", + "only" + ], + [ + "} and ", + "{IERC20-" + ], + [ + "Fun", + "d" + ], + [ + ".selector", + ", " + ], + [ + "Pri", + "mary" + ], + [ + "Dividend", + "s" + ], + [ + " F", + "OR " + ], + [ + "under", + "lying " + ], + [ + "separat", + "ely" + ], + [ + "allPair", + "s" + ], + [ + "draft", + "-" + ], + [ + "s any ", + "of the arithmetic of the contract" + ], + [ + "affect", + "s any of the arithmetic of the contract" + ], + [ + "no way ", + "affects any of the arithmetic of the contract" + ], + [ + "=", + "\\n " + ], + [ + "L", + "ev" + ], + [ + "a", + "4" + ], + [ + "r", + " := " + ], + [ + ", ", + "'" + ], + [ + "\\\"", + ",\\\"" + ], + [ + "\\n\\n ", + "// " + ], + [ + "Owner", + "Enumeration" + ], + [ + "in ", + "case " + ], + [ + "of the ", + "token" + ], + [ + "support", + "ed. " + ], + [ + "\\u00", + "26" + ], + [ + ";\\n }\\n\\n ", + "// =============================================================\\n // " + ], + [ + "}\\r\\n", + "\\r\\n " + ], + [ + "igh", + "t " + ], + [ + "uni", + "qu" + ], + [ + ", so ", + "we " + ], + [ + "swapExactETHFor", + "TokensSupportingFeeOnTransferTokens" + ], + [ + "\"// SPDX-License-Identifier: GPL-3.0", + "-or-later" + ], + [ + "Interface of the ERC20 standard as defined in the EIP", + ".\\n */\\ninterface IERC20" + ], + [ + "using the\\n * allowance mechanism. `amount` is then deducted ", + "from the caller's\\n * allowance" + ], + [ + "utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev ", + "Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\"" + ], + [ + "well-", + "known " + ], + [ + ".", + "\\n // " + ], + [ + "the ", + "non-" + ], + [ + "ERC20", + " is Context, IERC20" + ], + [ + "{\\n ", + "// " + ], + [ + "result ", + "+ (" + ], + [ + "Tax", + "es" + ], + [ + "use", + "ful" + ], + [ + "code ", + "is " + ], + [ + "IMP", + "LEMENT" + ], + [ + "tokenId ", + "+ " + ], + [ + "Sets the ", + "values for " + ], + [ + "EV", + "ENT" + ], + [ + "can only be ", + "set once " + ], + [ + "relationship", + " betwe" + ], + [ + "(", + "\\n " + ], + [ + "(", + ");\\n return " + ], + [ + "2", + "`, a balance of `" + ], + [ + "S", + "H" + ], + [ + "i", + "ev" + ], + [ + "s", + "oftwa" + ], + [ + "w", + "ik" + ], + [ + "\\n ", + "//" + ], + [ + ", ", + "imit" + ], + [ + "tr", + "ans" + ], + [ + "token", + "OfOwner" + ], + [ + "op", + "code" + ], + [ + "op", + "t for a " + ], + [ + "and ", + "Wei" + ], + [ + "false", + "` " + ], + [ + ", bytes32 ", + "value" + ], + [ + "Tokens ", + "usually " + ], + [ + "allowance for ", + "all " + ], + [ + "expect", + "ation" + ], + [ + " / ", + "10 ** 2" + ], + [ + "Set storage set", + ", bytes32 value" + ], + [ + " may ", + "not " + ], + [ + "immutable", + ": they " + ], + [ + "505", + "` tokens should" + ], + [ + "505", + " / 10 ** 2" + ], + [ + "values are ", + "immutable: they " + ], + [ + "Ether ", + "and Wei" + ], + [ + "ating the ", + "relationship betwe" + ], + [ + "value of 18", + ", imit" + ], + [ + "in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev ", + "Moves `amount` tokens from the caller's account" + ], + [ + "5` (`", + "505 / 10 ** 2" + ], + [ + "be displayed to a user as `", + "5" + ], + [ + "For example, if `decimals` equals `", + "2`, a balance of `" + ], + [ + "Lev", + "el" + ], + [ + "using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance", + ".\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom" + ], + [ + "opt for a ", + "value of 18, imit" + ], + [ + "Tokens usually ", + "opt for a value of 18, imit" + ], + [ + "values are immutable: they ", + "can only be set once " + ], + [ + "For example, if `decimals` equals `2`, a balance of `", + "505` tokens should" + ], + [ + "Tokens usually opt for a value of 18, imit", + "ating the relationship betwe" + ], + [ + ", ", + "// " + ], + [ + "Token", + "From" + ], + [ + "and ", + "does not " + ], + [ + "This ", + "allows " + ], + [ + "raw", + " " + ], + [ + "`.\\n *\\n * ", + "WARNING: " + ], + [ + "given ", + "token ID" + ], + [ + "DE", + "AD" + ], + [ + ") public virtual override returns (bool) {\\n ", + "address owner = _msgSender();\\n " + ], + [ + "> 0", + ", \\\"" + ], + [ + "Interface ", + "for the " + ], + [ + ">= amount, \\\"ERC20: ", + "transfer " + ], + [ + "For a ", + "detailed " + ], + [ + "limitsInE", + "ffect" + ], + [ + "We can ", + "directly " + ], + [ + "conflict ", + "with the " + ], + [ + "tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * ", + "condition is to first reduce the spender's allowance to 0 and set " + ], + [ + "no way affects any of the arithmetic of the contract", + ", includ" + ], + [ + "tokenOfOwner", + "ByIndex" + ], + [ + "values are immutable: they can only be set once ", + "dur" + ], + [ + "E", + "lement" + ], + [ + "R", + "ANT" + ], + [ + "^", + " " + ], + [ + "l", + "ess" + ], + [ + ", ", + "data" + ], + [ + "ag", + "nos" + ], + [ + ";\\n ", + "_owner = newOwner" + ], + [ + "operator", + " for " + ], + [ + "when ", + "dividing by " + ], + [ + "uint8", + "(" + ], + [ + "\\n\\npragma solidity ^", + "0.7.0" + ], + [ + "safeTransferFrom", + "(from, to, tokenId" + ], + [ + "owner ", + "or " + ], + [ + ";\\n emit ", + "OwnershipTransferred(oldOwner, newOwner" + ], + [ + "calcul", + "ate" + ], + [ + "uint24", + " " + ], + [ + "If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer", + ".\\n *\\n * Emits a {Transfer} event.\\n */\\n function " + ], + [ + "token by either {approve} or {setApprovalForAll}.\\n * - ", + "If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function " + ], + [ + "Sets `amount` as the allowance of `spender` over the caller's ", + "tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set " + ], + [ + "address oldOwner = _owner", + ";\\n _owner = newOwner" + ], + [ + "Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set ", + "the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from " + ], + [ + "address oldOwner = _owner;\\n _owner = newOwner", + ";\\n emit OwnershipTransferred(oldOwner, newOwner" + ], + [ + "v", + "s" + ], + [ + "en", + "ing to " + ], + [ + "ed ", + "general " + ], + [ + "a ", + "value " + ], + [ + "by ", + "list" + ], + [ + "add", + "ed in a " + ], + [ + "on ", + "calls to " + ], + [ + "balanceOf", + "} and {IERC20-" + ], + [ + "lin", + "es: " + ], + [ + "tic", + " to the " + ], + [ + "s to ", + "reconstruct the " + ], + [ + ". This ", + "behavior is " + ], + [ + "implementation", + "s of the " + ], + [ + "\\r\\n ", + "function " + ], + [ + "these ", + "events, " + ], + [ + "follow", + "ed general " + ], + [ + "{IERC20-", + "balanceOf} and {IERC20-" + ], + [ + ". O", + "ther " + ], + [ + "application", + "s to reconstruct the " + ], + [ + "OU", + "T " + ], + [ + "tokens are ", + "created" + ], + [ + "\\\");\\r\\n ", + "require(" + ], + [ + "guarant", + "ee" + ], + [ + "guide", + "lines: " + ], + [ + "required by the ", + "specification" + ], + [ + "Lp", + "Burn" + ], + [ + "_remove", + "TokenFrom" + ], + [ + "latest", + "/" + ], + [ + "field", + "s " + ], + [ + "Bool", + "e" + ], + [ + "derived ", + "contract " + ], + [ + "on failure", + ". This behavior is " + ], + [ + "events", + ". Other " + ], + [ + "We have ", + "followed general " + ], + [ + " is emitted ", + "on calls to " + ], + [ + "result + (", + "rounding == Rounding.Up && " + ], + [ + "Sets the values for ", + "{" + ], + [ + "false` ", + "on failure. This behavior is " + ], + [ + "allowance for all ", + "accounts " + ], + [ + "expectation", + "s of " + ], + [ + "by list", + "ening to " + ], + [ + "these events, ", + "as it " + ], + [ + "{IERC20-balanceOf} and {IERC20-", + "transfer" + ], + [ + "applications to reconstruct the ", + "allowance for all accounts " + ], + [ + "guidelines: ", + "functions " + ], + [ + "events. Other ", + "implementations of the " + ], + [ + "false` on failure. This behavior is ", + "nonethel" + ], + [ + "=", + "\\u003e " + ], + [ + "N", + "E" + ], + [ + "{", + "decreaseAllowance" + ], + [ + "re", + "lies " + ], + [ + "a ", + ": " + ], + [ + "return ", + "c" + ], + [ + "This ", + "method " + ], + [ + "This ", + "implementation is " + ], + [ + "with ", + "custom message " + ], + [ + ";\\n\\n ", + "mapping(address => " + ], + [ + "@param", + " to " + ], + [ + "))", + "\\n " + ], + [ + ":= ", + "add(" + ], + [ + "St", + "age" + ], + [ + "way ", + "tokens are created" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (", + "utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\"" + ], + [ + "lp", + "Pair" + ], + [ + "supply ", + "mechanism " + ], + [ + "mitig", + "ate the " + ], + [ + "unt", + "il" + ], + [ + ". This include", + "s " + ], + [ + "that a ", + "supply mechanism " + ], + [ + ")\\n public", + "\\n view" + ], + [ + "at a ", + "time" + ], + [ + "issues ", + "around " + ], + [ + "Ou", + "t " + ], + [ + "erc721", + "a" + ], + [ + "Additionally, ", + "an {Approval} event" + ], + [ + "Posi", + "tion" + ], + [ + "Finally, ", + "the non-" + ], + [ + "added to ", + "mitigate the " + ], + [ + "has to be ", + "added in a " + ], + [ + "well-known ", + "issues around " + ], + [ + "agnos", + "tic to the " + ], + [ + "Sets the values for {", + "name" + ], + [ + "This implementation is ", + "agnostic to the " + ], + [ + "way tokens are created", + ". This " + ], + [ + "that a supply mechanism ", + "has to be added in a " + ], + [ + "Additionally, an {Approval} event", + " is emitted on calls to " + ], + [ + "Finally, the non-", + "standard " + ], + [ + "added to mitigate the ", + "well-known issues around " + ], + [ + "This implementation is agnostic to the ", + "way tokens are created. This " + ], + [ + "that a supply mechanism has to be added in a ", + "derived contract " + ], + [ + "M", + "edia" + ], + [ + "return", + "ing `" + ], + [ + ") {", + "\\r\\n " + ], + [ + "for ", + "which " + ], + [ + "not ", + "revert" + ], + [ + "string ", + "public " + ], + [ + "EIP", + " may not " + ], + [ + "Mo", + "de" + ], + [ + "supply", + "-" + ], + [ + "follow", + "ing\\n * " + ], + [ + "} and {", + "increaseAllowance" + ], + [ + ".sol\\\";\\nimport \\\"../../", + "../" + ], + [ + "keccak256(", + "bytes(" + ], + [ + "(uint256 value) internal pure returns (", + "string memory) {\\n " + ], + [ + "i.e. ", + "`" + ], + [ + "using {", + "_mint" + ], + [ + "more expensi", + "ve " + ], + [ + "mu", + "ch " + ], + [ + "said ", + "events. Other implementations of the " + ], + [ + "Consecutive", + "Transfer" + ], + [ + "of these ", + "values are immutable: they can only be set once dur" + ], + [ + "Ether and Wei", + ". This is the " + ], + [ + "and does not ", + "conflict with the " + ], + [ + "This allows ", + "applications to reconstruct the allowance for all accounts " + ], + [ + "by listening to ", + "said events. Other implementations of the " + ], + [ + "{decreaseAllowance", + "} and {increaseAllowance" + ], + [ + "Finally, the non-standard ", + "{decreaseAllowance} and {increaseAllowance" + ], + [ + "that a supply mechanism has to be added in a derived contract ", + "using {_mint" + ], + [ + "returning `", + "false` on failure. This behavior is nonethel" + ], + [ + "EIP may not ", + "emit" + ], + [ + "and does not conflict with the ", + "expectations of " + ], + [ + "This allows applications to reconstruct the allowance for all accounts ", + "just" + ], + [ + "by listening to said events. Other implementations of the ", + "EIP may not emit" + ], + [ + "-", + "erc20-" + ], + [ + "[", + "How" + ], + [ + "]", + ";\\n\\n " + ], + [ + "d", + "ue " + ], + [ + "{", + "_" + ], + [ + "er", + "gen" + ], + [ + "uint256", + ") {\\r\\n " + ], + [ + "ail", + "ed" + ], + [ + "\\r\\n ", + "*" + ], + [ + "Contract", + "OnERC721Received" + ], + [ + "Own", + "able " + ], + [ + "implement", + "-erc20-" + ], + [ + "allowances", + ". " + ], + [ + "SafeMath", + " for uint256" + ], + [ + "using ", + "`" + ], + [ + "_balances[", + "recipient" + ], + [ + "functions ", + "have been " + ], + [ + "delegat", + "es" + ], + [ + "up ", + "see " + ], + [ + ") external;\\n\\n /**\\n * @dev ", + "Returns the " + ], + [ + "mechanisms", + "/2" + ], + [ + "write", + "up see " + ], + [ + "IL", + "ITY" + ], + [ + "/// @solidity memory-safe-assembly", + "\\n assembly {\\n " + ], + [ + "how-", + "to-" + ], + [ + "Role(role, account", + ");\\n }\\n\\n /**\\n * @dev " + ], + [ + "Implementation of the {", + "IERC20" + ], + [ + "t/", + "how-to-" + ], + [ + "Ke", + "y" + ], + [ + "Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner", + "` functions anymore. " + ], + [ + "IMPLEMENT", + "ATION" + ], + [ + "For a detailed ", + "writeup see " + ], + [ + "Additionally, an {Approval} event is emitted on calls to ", + "{transferFrom" + ], + [ + "added to mitigate the well-known issues around ", + "setting" + ], + [ + "supply-", + "mechanisms/2" + ], + [ + "implement-erc20-", + "supply-mechanisms/2" + ], + [ + "functions have been ", + "added to mitigate the well-known issues around setting" + ], + [ + "t/how-to-", + "implement-erc20-supply-mechanisms/2" + ], + [ + "For a detailed writeup see ", + "our " + ], + [ + "t/how-to-implement-erc20-supply-mechanisms/2", + "26" + ], + [ + "_", + "receiver" + ], + [ + "c", + "atch" + ], + [ + "h", + "old " + ], + [ + "p", + "e" + ], + [ + "r", + "ate " + ], + [ + ");", + "\\n }\\n" + ], + [ + "it", + "em" + ], + [ + "` ", + "in packed " + ], + [ + "no", + "de" + ], + [ + "Transfer", + "CallerNotOwnerNorApproved" + ], + [ + "bu", + "g" + ], + [ + "totalSupply", + "}.\\n */\\n function totalSupply() public view virtual override returns (" + ], + [ + "buy", + "back" + ], + [ + "Min", + ",\\n uint amount" + ], + [ + "s to ", + "be " + ], + [ + "implement ", + "supply " + ], + [ + "the zero address\\\");\\n\\n ", + "_allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount" + ], + [ + "keccak256(abi.encode", + "Packed(\\\"" + ], + [ + "fixed ", + "point " + ], + [ + "For a ", + "generic " + ], + [ + ") {\\n if (", + "success" + ], + [ + "TIP: ", + "For a detailed writeup see our " + ], + [ + "protect ", + "against " + ], + [ + "Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby ", + "removing " + ], + [ + ") external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev ", + "Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from " + ], + [ + "allowances. ", + "See {IERC20-approve}." + ], + [ + "Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. ", + "Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing " + ], + [ + "t/how-to-implement-erc20-supply-mechanisms/226", + "[How" + ], + [ + "implement supply ", + "mechanisms" + ], + [ + "For a generic ", + "mechanism " + ], + [ + "TIP: For a detailed writeup see our ", + "guide" + ], + [ + "6", + "2" + ], + [ + "K", + "S" + ], + [ + "an", + "\\n * " + ], + [ + "ERC", + "1967" + ], + [ + "(address ", + "to" + ], + [ + "wh", + "ile" + ], + [ + "In", + "spired by " + ], + [ + ") public ", + "override " + ], + [ + "when ", + "they are " + ], + [ + ";\\n ", + "string private _symbol" + ], + [ + "Pack", + "ed " + ], + [ + "signature ", + "fields " + ], + [ + "11", + "/" + ], + [ + "_transferOwnership", + "(address newOwner" + ], + [ + "Or", + "Registr" + ], + [ + "receive", + "s the `" + ], + [ + "} and {", + "symbol" + ], + [ + "prevOwnership", + "Packed " + ], + [ + "} that ", + "receives the `" + ], + [ + "subscription", + "OrRegistr" + ], + [ + "rang", + "e " + ], + [ + " of {", + "ECDSA-" + ], + [ + "string private _name", + ";\\n string private _symbol" + ], + [ + "Overload", + " of {ECDSA-" + ], + [ + "123456789", + "abcdef" + ], + [ + "Sets the values for {name", + "} and {symbol" + ], + [ + "For a generic mechanism ", + "see {" + ], + [ + "signature fields ", + "separately" + ], + [ + "subscriptionOrRegistr", + "ant" + ], + [ + "V", + "o" + ], + [ + "╠", + "╠" + ], + [ + " *", + " _" + ], + [ + ", ", + "IERC721" + ], + [ + "token", + "s." + ], + [ + "To", + "ZeroAddress" + ], + [ + "view ", + "returns(" + ], + [ + "Address", + "Set storage set" + ], + [ + "Ex", + "p" + ], + [ + "remain", + "der " + ], + [ + "Uint", + "Set storage set" + ], + [ + "wei", + "ght" + ], + [ + "Point", + "s" + ], + [ + "Sets `amount` as the allowance of `spender` over the ", + "`owner` s " + ], + [ + "2", + "1" + ], + [ + "W", + "AP" + ], + [ + "_", + "base" + ], + [ + "b", + "etwe" + ], + [ + "}", + ") " + ], + [ + "uint", + "224" + ], + [ + "256", + " bits " + ], + [ + "the ", + "contract " + ], + [ + "value ", + ">>= " + ], + [ + "pay", + "out" + ], + [ + "allowance", + "}.\\n */\\n function " + ], + [ + "tokens", + ".\\n *\\n * This " + ], + [ + "Per", + "Token" + ], + [ + ") private ", + "returns (bool) {\\n " + ], + [ + "block.", + "chainid" + ], + [ + "_Available since ", + "v3." + ], + [ + "_S", + "IGN" + ], + [ + "(tokenId", + ", " + ], + [ + "last", + "TokenId" + ], + [ + "amount exceed", + "s the " + ], + [ + "unsigned integ", + "er " + ], + [ + "Zero", + "Quantity" + ], + [ + "return true", + ";\\n }\\n\\n /**\\n * @dev " + ], + [ + "access/Ownable", + ".sol\"" + ], + [ + "conc", + "at" + ], + [ + "propos", + "al" + ], + [ + " ? ", + "a : " + ], + [ + "Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing ", + "any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n " + ], + [ + "W", + "indow" + ], + [ + "b", + "ul" + ], + [ + "f", + "actor" + ], + [ + "w", + "." + ], + [ + "for ", + "`" + ], + [ + "if (", + "b" + ], + [ + "on ", + "error" + ], + [ + ".\\n */\\n function _", + "approve" + ], + [ + "decimals", + "() external view returns (" + ], + [ + "Min", + ",\\n address to,\\n uint deadline" + ], + [ + " <", + " _" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - ", + "the caller must have " + ], + [ + "safeTransferFrom", + "}\\n * " + ], + [ + "dep", + "rec" + ], + [ + "amount0", + "Out" + ], + [ + ");\\n }\\n }\\n\\n /**\\n * @dev ", + "Returns the " + ], + [ + "orac", + "le" + ], + [ + ");\\n return ", + "result + (rounding == Rounding.Up && " + ], + [ + ") internal pure returns (uint256) {\\n unchecked {\\n ", + "uint256 result = " + ], + [ + "acce", + "pt" + ], + [ + ", Rounding rounding", + ") internal pure returns (uint256) {\\n unchecked {\\n uint256 result = " + ], + [ + "A", + "I" + ], + [ + "\\n * ", + "greater than largest " + ], + [ + "\\n\\n ", + "struct " + ], + [ + "owner", + "` cannot be the zero address.\\n * - `" + ], + [ + "\\n * ", + "function " + ], + [ + "token ", + "id " + ], + [ + "address(0", + ") " + ], + [ + "abi", + "lities" + ], + [ + "(\\n address ", + "to" + ], + [ + "hash", + " of the " + ], + [ + "transferFrom", + "}" + ], + [ + "\\\\", + "__" + ], + [ + "total ", + "number of tokens " + ], + [ + "IERC721Receiver", + "(to)." + ], + [ + "AN", + "Y " + ], + [ + "AB", + "ILITY" + ], + [ + "_transferOwnership(", + "newOwner" + ], + [ + "_allowances[owner][spender", + "];\\n }\\n\\n /**\\n * @dev See {IERC20-" + ], + [ + "reverting on\\n * overflow (when the input is ", + "less than smallest " + ], + [ + "Operations", + "Fee" + ], + [ + ";\\n\\n uint256 private ", + "_totalSupply" + ], + [ + ".\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `", + "owner` cannot be the zero address.\\n * - `" + ], + [ + "gas.\\n */\\n function ", + "supportsInterface(bytes4 interfaceId" + ], + [ + "int256, ", + "reverting on\\n * overflow (when the input is less than smallest " + ], + [ + "updAd", + "s" + ], + [ + "owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to ", + "the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount" + ], + [ + "IMPLEMENTATION", + "_SLOT" + ], + [ + "(", + ")." + ], + [ + "9", + "b" + ], + [ + "F", + "I" + ], + [ + "F", + "X" + ], + [ + "S", + "ET" + ], + [ + "as", + "set " + ], + [ + "uint ", + "liquidity" + ], + [ + "ig", + "ht" + ], + [ + "}\\n }\\n\\n /**\\n * @dev ", + "Returns the " + ], + [ + ";\\n }\\n\\n /**\\n * @dev See {IERC20-", + "balanceOf}.\\n */\\n function " + ], + [ + "WAR", + "RANT" + ], + [ + ".\\n */\\n constructor(", + ") {\\n " + ], + [ + "Pric", + "e " + ], + [ + "Cach", + "e" + ], + [ + "transfer}", + ".\\n *\\n * Requirements:\\n *\\n * - `" + ], + [ + "];\\n }\\n\\n /**\\n * @dev See {IERC20-", + "transfer}.\\n *\\n * Requirements:\\n *\\n * - `" + ], + [ + ");\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-", + "allowance}.\\n */\\n function " + ], + [ + "Bas", + "ic" + ], + [ + "_approve(_msgSender(), ", + "spender, " + ], + [ + "}(\\\"", + "\\\");\\n require(" + ], + [ + "existing ", + "when they are " + ], + [ + ".", + "\\n " + ], + [ + "b", + "t" + ], + [ + "in", + "c" + ], + [ + "uint256", + "(_" + ], + [ + "====", + "\\n */\\n function " + ], + [ + ": ", + "hex " + ], + [ + "For", + "ETH" + ], + [ + "block", + "Timestamp" + ], + [ + ">= ", + "value" + ], + [ + "number", + "Burned" + ], + [ + "Counter", + "s." + ], + [ + "_balances[account", + "];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `" + ], + [ + "Strings", + ": hex " + ], + [ + ".\\n * - ", + "the caller must have a balance of at least `amount" + ], + [ + "Revert", + "s " + ], + [ + "length ", + "insufficient" + ], + [ + "paus", + "ed(" + ], + [ + "Strings: hex ", + "length insufficient" + ], + [ + ".\\n * - the caller must have a balance of at least `amount", + "`.\\n */\\n function " + ], + [ + "_", + "callOptionalReturn" + ], + [ + "h", + "ere " + ], + [ + "l", + "er" + ], + [ + "de", + "cod" + ], + [ + "\\\"", + "\\\"" + ], + [ + "ay", + "out" + ], + [ + "Index", + "[tokenId" + ], + [ + ")\\n {\\n ", + "return " + ], + [ + "stored ", + "at " + ], + [ + ".\\n *\\n * Emits an {Approval} event indicating the updated allowance", + ". This is " + ], + [ + "can be used to\\n * e.g. ", + "set automatic allowances for certain subsystems, etc" + ], + [ + "not\\n * ", + "required by the EIP. See the note at the beginning of {ERC20" + ], + [ + "Softwa", + "re " + ], + [ + "internal function is equivalent to `approve`, and ", + "can be used to\\n * e.g. set automatic allowances for certain subsystems, etc" + ], + [ + "decimals() external view returns (", + "uint8" + ], + [ + "transferFrom}", + ".\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is " + ], + [ + "transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is ", + "not\\n * required by the EIP. See the note at the beginning of {ERC20" + ], + [ + "(", + "address" + ], + [ + ")", + ".\\n */\\n function _" + ], + [ + "1", + "." + ], + [ + "5", + "00" + ], + [ + "_", + "RE" + ], + [ + "uint256", + ")" + ], + [ + ") ", + "returns (" + ], + [ + "Fee", + "Total" + ], + [ + "new", + "Allowance" + ], + [ + "updat", + "e " + ], + [ + ":= ", + "sub(" + ], + [ + "`.\\n * - ", + "the caller must have allowance for " + ], + [ + ";\\n }\\n ", + "if (" + ], + [ + "uint64", + "(" + ], + [ + "number of tokens ", + "in " + ], + [ + "_Available since v4.", + "1._" + ], + [ + "spender` cannot be the zero address", + ".\\n */\\n function _approve" + ], + [ + "call to non-contract", + "\"" + ], + [ + "packedAddressData", + "[owner" + ], + [ + "_dev", + "Fee" + ], + [ + "sal", + "e " + ], + [ + "can be used to\\n * e.g. ", + "implement automatic token fees, slashing mechanisms, etc" + ], + [ + "total supply.\\n *\\n * Emits a {Transfer} event with ", + "`from` " + ], + [ + "reduc", + "ing the\\n * " + ], + [ + "requen", + "cy" + ], + [ + "internal function is equivalent to {transfer}, and ", + "can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc" + ], + [ + "uint256) {\\n return _totalSupply", + ";\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function " + ], + [ + "Boole", + "an" + ], + [ + "betwe", + "en " + ], + [ + ".\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `", + "spender` cannot be the zero address.\\n */\\n function _approve" + ], + [ + "internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc", + ".\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve" + ], + [ + "2", + ".0" + ], + [ + "m", + "id" + ], + [ + "s", + "ort" + ], + [ + "w", + "ra" + ], + [ + "\\n *", + " " + ], + [ + "bl", + "y " + ], + [ + " of ", + "a " + ], + [ + ");\\n }\\n\\n ", + "/// @notice " + ], + [ + "bytes4", + "(" + ], + [ + "(token", + "." + ], + [ + ");\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-", + "transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20" + ], + [ + "ww", + "w." + ], + [ + "total supply.\\n *\\n * Emits a {Transfer} event with ", + "`to` " + ], + [ + "reentrancy ", + "vulner" + ], + [ + "trig", + "ge" + ], + [ + "ing\\n * the ", + "total supply.\\n *\\n * Emits a {Transfer} event with `from` " + ], + [ + ";\\n\\n // The bit position", + " of `" + ], + [ + "reducing the\\n * ", + "total supply.\\n *\\n * Emits a {Transfer} event with `to` " + ], + [ + "internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc", + ".\\n *\\n * Emits a {Transfer" + ], + [ + "_", + ", " + ], + [ + "s", + ".\\n *\\n * " + ], + [ + "it", + "self" + ], + [ + ");\\n ", + "emit " + ], + [ + ";\\n\\n", + "import {" + ], + [ + "Per", + "mit " + ], + [ + "`, ", + "`" + ], + [ + "` cannot be the zero address.\\n * - `", + "account` must have at least `amount` " + ], + [ + "_burn", + "Counter" + ], + [ + "Check", + " " + ], + [ + "`.\\n */\\n function ", + "_transfer" + ], + [ + "not", + "bot" + ], + [ + "claim", + "ed" + ], + [ + "previous ", + "owner" + ], + [ + "Hold", + "ing" + ], + [ + "kee", + "p" + ], + [ + "ser", + "v" + ], + [ + "tokens of at least\\n * `amount`.\\n */\\n function ", + "transferFrom" + ], + [ + "OW", + "N" + ], + [ + "compli", + "ant " + ], + [ + " @dev Creates `amount` tokens and assigns them to `account`, increas", + "ing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` " + ], + [ + "-", + "call" + ], + [ + "_", + "ref" + ], + [ + "es", + "c" + ], + [ + " = ", + "keccak256(\\\"" + ], + [ + ";\\n\\n", + "import '" + ], + [ + "lin", + "k" + ], + [ + "Pay", + "out" + ], + [ + "Lo", + "an" + ], + [ + "the\\n * ", + "name" + ], + [ + "address(0)", + ");\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n " + ], + [ + "1;\\n ", + "}\\n " + ], + [ + ";\\n ", + "}\\n\\n " + ], + [ + "ed, ", + "use {" + ], + [ + "amount1", + "Out" + ], + [ + "spender, amount", + ");\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20" + ], + [ + "this method ", + "is discourag" + ], + [ + "_statu", + "s" + ], + [ + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically ", + "de" + ], + [ + "domain separator", + " " + ], + [ + ", since ", + "the " + ], + [ + "spender` must have allowance for the caller of at least", + "\\n * `" + ], + [ + "Usage of ", + "this method is discourag" + ], + [ + "symbol of the token, usually a shorter version of ", + "the\\n * name" + ], + [ + "` cannot be the zero address.\\n * - `account` must have at least `amount` ", + "tokens" + ], + [ + "Usage of this method is discourag", + "ed, use {" + ], + [ + "_", + "user" + ], + [ + "in", + "creases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance" + ], + [ + "if", + "orm" + ], + [ + "if ", + "present" + ], + [ + "new", + "Balance" + ], + [ + "di", + "bly " + ], + [ + ");\\n\\n /**\\n * @dev ", + "Safely transfers `tokenId` token from `from` to `to" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `", + "spender` cannot be the zero address.\\n * - `" + ], + [ + "_t", + "FeeTotal" + ], + [ + " from ", + "uint256, reverting on\\n * overflow (when the input is greater than largest " + ], + [ + "incre", + "dibly " + ], + [ + "type", + "Hash" + ], + [ + ") internal virtual {\\n require(", + "owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount" + ], + [ + "```", + "solidity" + ], + [ + "drop", + " " + ], + [ + ".\\n */\\n constructor(", + "string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_" + ], + [ + "creases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance", + ".\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `" + ], + [ + "token/ERC721/extensions/", + "IERC721Metadata" + ], + [ + "_rol", + "es" + ], + [ + ");\\n }\\n\\n /**", + " @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` " + ], + [ + "_CO", + "MP" + ], + [ + "whenever ", + "possible" + ], + [ + "ExcludeFrom", + "Fees" + ], + [ + "taken to ", + "not " + ], + [ + "RecoverError ", + "error" + ], + [ + ");\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function ", + "allowance(address owner, address spender" + ], + [ + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically de", + "creases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `" + ], + [ + "symbol of the token, usually a shorter version of the\\n * name", + ".\\n */\\n function symbol" + ], + [ + "` cannot be the zero address.\\n * - `account` must have at least `amount` tokens", + ".\\n */\\n function _burn" + ], + [ + "increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance", + ".\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function " + ], + [ + "incredibly ", + "unrealis" + ], + [ + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `", + "spender` must have allowance for the caller of at least\\n * `" + ], + [ + "E", + " = " + ], + [ + "P", + "C " + ], + [ + "i", + "al" + ], + [ + "m", + "ark" + ], + [ + "uint256", + "[] calldata " + ], + [ + "ex", + "chang" + ], + [ + "wh", + "itelist " + ], + [ + "max", + "TxAmount" + ], + [ + "this ", + "library " + ], + [ + "Returns ", + "if the " + ], + [ + "subtractedValue", + "`.\\n */\\n function " + ], + [ + ";\\n }\\n\\n /**\\n * @dev Returns the ", + "symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol" + ], + [ + ".\\n ", + "//" + ], + [ + "isContract", + "(address account" + ], + [ + "percent", + "age " + ], + [ + "PAR", + "T" + ], + [ + "zero.\\n *\\n * ", + "Counterpart to Solidity's `" + ], + [ + "mint to ", + "the zero address\\\");\\n\\n _beforeTokenTransfer" + ], + [ + "_msgSenderERC721A", + "())" + ], + [ + "out of ", + "bound" + ], + [ + "succ", + "ess " + ], + [ + "abi.encodeWithSelector", + "(token." + ], + [ + "This implementation is agnostic to the way tokens are created. This ", + "means\\n * " + ], + [ + "For a generic mechanism see {", + "ERC20PresetMinterPauser" + ], + [ + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `", + "subtractedValue`.\\n */\\n function " + ], + [ + "J", + "B" + ], + [ + "T", + "X" + ], + [ + "`", + "hash" + ], + [ + "s", + "w" + ], + [ + "}", + ").\\n *\\n * " + ], + [ + ", ", + "ERC165" + ], + [ + "ma", + "g" + ], + [ + "Transfer", + "From" + ], + [ + "\\n * ", + "these events, as it " + ], + [ + "\\n * ", + "by listening to said events. Other implementations of the EIP may not emit" + ], + [ + "IERC20", + "(" + ], + [ + ";\\n\\n ", + "string private _name;\\n string private _symbol" + ], + [ + ",\\n address ", + "indexed " + ], + [ + "MIN", + "T_" + ], + [ + "`.\\n *\\n * ", + "See {" + ], + [ + "`operator", + "` " + ], + [ + "application", + "s.\\n *\\n * " + ], + [ + "oo", + "st" + ], + [ + "lower ", + "160" + ], + [ + "ear", + "ly" + ], + [ + ") public view virtual override returns (uint256) {\\n return ", + "_allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-" + ], + [ + "que", + "ue" + ], + [ + "`recipient", + "`, " + ], + [ + "} interface.\\n *\\n * ", + "This implementation is agnostic to the way tokens are created. This means\\n * " + ], + [ + "amountToSwap", + "ForETH" + ], + [ + "Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner", + ".\\n */\\n constructor() {\\n " + ], + [ + "This allows applications to reconstruct the allowance for all accounts just", + "\\n * by listening to said events. Other implementations of the EIP may not emit" + ], + [ + "uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function ", + "balanceOf(address account" + ], + [ + "} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * ", + "that a supply mechanism has to be added in a derived contract using {_mint" + ], + [ + "This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit", + "\\n * these events, as it " + ], + [ + "5", + "4" + ], + [ + "A", + "0" + ], + [ + "E", + "ar" + ], + [ + "L", + "IC" + ], + [ + "or ", + "remove " + ], + [ + "Tr", + "ading " + ], + [ + "vo", + "c" + ], + [ + "E_", + "HASH" + ], + [ + "Check", + "er" + ], + [ + "possibl", + "y " + ], + [ + ", uint ", + "p3) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(" + ], + [ + "Be", + "acon" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.", + "6" + ], + [ + "}.\\n * ", + "This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it " + ], + [ + "transferred to `to`.\\n * - when `from` is zero, `amount` ", + "tokens will be " + ], + [ + "compl", + "ex" + ], + [ + ")\\\", p0, p1, p2));\\n\\t}\\n\\n\\tfunction ", + "log(" + ], + [ + "expir", + "y" + ], + [ + ")) private _allowances", + ";\\n\\n uint256 private _totalSupply" + ], + [ + "(int256 value) internal pure returns (", + "int" + ], + [ + "throwError", + "(" + ], + [ + "required by the specification", + ".\\n *\\n * " + ], + [ + "Implementation of the {IERC20", + "} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint" + ], + [ + "Additionally, an {Approval} event is emitted on calls to {transferFrom", + "}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it " + ], + [ + "functions have been added to mitigate the well-known issues around setting", + "\\n * " + ], + [ + "increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function ", + "increaseAllowance(address spender, uint256 addedValue" + ], + [ + "applications.\\n *\\n * ", + "Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it " + ], + [ + "B", + "orrow" + ], + [ + "T", + "256" + ], + [ + "/**", + "\\n * @dev " + ], + [ + "bytes", + "1" + ], + [ + "that ", + "will be " + ], + [ + "current", + "ly " + ], + [ + ").", + "interfaceId" + ], + [ + "_owner", + "s" + ], + [ + "` cannot be ", + "the caller" + ], + [ + "\\\\", + " " + ], + [ + "gen", + "ce" + ], + [ + "Au", + "x" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Returns the ", + "name of the token.\\n */\\n function name" + ], + [ + "ir", + "u" + ], + [ + "insufficient ", + "allowance" + ], + [ + "a / ", + "b" + ], + [ + "correct", + "ly " + ], + [ + "}\\n * ", + "functions have been added to mitigate the well-known issues around setting\\n * " + ], + [ + "}.\\n *\\n * ", + "TIP: For a detailed writeup see our guide" + ], + [ + "\\n * https://", + "forum." + ], + [ + "\\n * to ", + "implement supply mechanisms" + ], + [ + "(account, address(0), amount", + ");\\n }\\n\\n /**\\n * @dev " + ], + [ + "Finally, the non-standard {decreaseAllowance} and {increaseAllowance", + "}\\n * functions have been added to mitigate the well-known issues around setting\\n * " + ], + [ + "t/how-to-implement-erc20-supply-mechanisms/226[How", + "\\n * to implement supply mechanisms" + ], + [ + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function ", + "decreaseAllowance(address spender, uint256 subtractedValue" + ], + [ + "required by the specification.\\n *\\n * ", + "Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * " + ], + [ + "}.\\n *\\n * TIP: For a detailed writeup see our guide", + "\\n * https://forum." + ], + [ + "t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms", + "].\\n *\\n * " + ], + [ + "required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * ", + "allowances. See {IERC20-approve}." + ], + [ + "1", + "e18" + ], + [ + "5", + "7" + ], + [ + "K", + "ee" + ], + [ + "_", + "O" + ], + [ + "b", + "7" + ], + [ + "\\n *", + " " + ], + [ + "li", + "k" + ], + [ + "and", + "(" + ], + [ + "ing\\n * ", + "construction" + ], + [ + "such ", + "that " + ], + [ + "`tokenId` token", + " to another " + ], + [ + "ves ", + "permission" + ], + [ + "hal", + "f" + ], + [ + " to `to", + "` to transfer " + ], + [ + "0.6.0", + " <0.8.0" + ], + [ + "burn from ", + "the zero address\\\");\\n\\n _beforeTokenTransfer" + ], + [ + "(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: ", + "mint to the zero address\\\");\\n\\n _beforeTokenTransfer" + ], + [ + "(address(0), account, amount);\\n\\n ", + "_totalSupply " + ], + [ + "-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall", + "(address target, bytes memory data" + ], + [ + "s from the ", + "previous owner" + ], + [ + "Gi", + "ves permission" + ], + [ + "additional", + "Payee" + ], + [ + "_START", + "_TIMESTAMP" + ], + [ + "`.\\n *\\n * WARNING: ", + "Usage of this method is discouraged, use {" + ], + [ + "}(\\\"\\\");\\n require(", + "success" + ], + [ + "Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint", + "}.\\n * " + ], + [ + "`tokenId` token to another ", + "account" + ], + [ + " to `to` to transfer ", + "`tokenId` token to another account" + ], + [ + "Gives permission", + " to `to` to transfer `tokenId` token to another account" + ], + [ + " ", + "amount " + ], + [ + "1", + "B" + ], + [ + "M", + " " + ], + [ + "_", + "verifyCallResult" + ], + [ + "s", + ") " + ], + [ + "re", + ": " + ], + [ + "\\n * ", + "be displayed to a user as `5" + ], + [ + "ex", + "act " + ], + [ + "ly", + "ing" + ], + [ + "lo", + "op" + ], + [ + "Addres", + "s for " + ], + [ + "Ma", + "y " + ], + [ + ".\\n * ", + "For example, if `decimals` equals `2`, a balance of `505` tokens should" + ], + [ + "+= ", + "1" + ], + [ + "Sell", + "Fee" + ], + [ + "timestamp", + " of " + ], + [ + "registr", + "y" + ], + [ + ");\\n }", + "\\n }\\n}\\n\"" + ], + [ + "Fin", + "ish" + ], + [ + "s with ", + "a " + ], + [ + "override returns (bool", + ") {\\n return interfaceId == type(" + ], + [ + "oo", + "d " + ], + [ + "`).\\n *\\n * ", + "Tokens usually opt for a value of 18, imitating the relationship betwe" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function ", + "approve(address spender, uint256 amount" + ], + [ + "5` (`505 / 10 ** 2", + "`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship betwe" + ], + [ + "burn from the zero address\\\");\\n\\n _beforeTokenTransfer", + "(account, address(0), amount);\\n\\n " + ], + [ + ".\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should", + "\\n * be displayed to a user as `5" + ], + [ + "in", + "s" + ], + [ + "in", + "put" + ], + [ + "\\\"", + ")" + ], + [ + "return ", + "value" + ], + [ + "Address", + "Slot" + ], + [ + "par", + "tic" + ], + [ + "log", + "ic" + ], + [ + "_transfer", + "(from, to, tokenId" + ], + [ + "pragma solidity ", + "0.6." + ], + [ + "URI", + " " + ], + [ + "\\n // ", + "@param _" + ], + [ + ")\\\", p0", + "));\\n\\t}\\n\\n\\tfunction " + ], + [ + "ERC721A", + "Queryable" + ], + [ + "s a ", + "value " + ], + [ + "address,", + "string," + ], + [ + "address,", + "bool," + ], + [ + "p0", + ") internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(" + ], + [ + " := ", + "sub(" + ], + [ + "Uint", + "Set" + ], + [ + "token/ERC721/", + "IERC721Receiver" + ], + [ + "stak", + "ing" + ], + [ + ")\\\", p0, p1, p2, p3));\\n\\t}\\n\\n\\tfunction log(", + "uint " + ], + [ + "********************************", + "********************************" + ], + [ + "produc", + "t" + ], + [ + "_ENT", + "RY" + ], + [ + "_transferOwnership(", + "_msgSender()" + ], + [ + "_DATA", + "_ENTRY" + ], + [ + "BITMASK_ADDRESS", + "_DATA_ENTRY" + ], + [ + "in\\n * ", + "no way affects any of the arithmetic of the contract, includ" + ], + [ + "`isContract", + "` will " + ], + [ + "Subtr", + "action " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, ", + "reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` " + ], + [ + ";\\n }\\n\\n /**\\n * @dev Returns the number of ", + "decimals used to get its user representation" + ], + [ + "information is only used for _display_ purposes: it ", + "in\\n * no way affects any of the arithmetic of the contract, includ" + ], + [ + "required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.", + "\\n */\\ncontract " + ], + [ + "5` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship betwe", + "en\\n * " + ], + [ + ";\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation", + ".\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5" + ], + [ + "(", + "address(" + ], + [ + ".", + "*" + ], + [ + "A", + "t " + ], + [ + "G", + "as " + ], + [ + "N", + "D" + ], + [ + "_", + "account" + ], + [ + "res", + "tore" + ], + [ + "us", + "e the " + ], + [ + "sp", + "l" + ], + [ + "that ", + "it " + ], + [ + "est", + "ed" + ], + [ + ") {\\n ", + "revert(\\\"" + ], + [ + "}.\\n */\\n function ", + "decimals" + ], + [ + "fir", + "m" + ], + [ + "[`", + "eth_sign" + ], + [ + "Add", + "ed" + ], + [ + "ing\\n * ", + "{IERC20-balanceOf} and {IERC20-transfer" + ], + [ + "AU", + "S" + ], + [ + "BITPOS", + "_START_TIMESTAMP" + ], + [ + "royal", + "ties" + ], + [ + "`operator", + "` to " + ], + [ + "Sh", + "ort" + ], + [ + "Rel", + "eas" + ], + [ + "(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: ", + "burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n " + ], + [ + "BITPOS_NUMBER_", + "MINTED" + ], + [ + "Calcul", + "ates " + ], + [ + ".start", + "Timestamp" + ], + [ + "consi", + "der" + ], + [ + "Perform", + "s a " + ], + [ + "upgradeable", + "/" + ], + [ + "(token, ", + "abi.encodeWithSelector(token." + ], + [ + "amount must be greater than ", + "zero\"" + ], + [ + "address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner", + ");\\n }\\n}\\n\"" + ], + [ + "of these values are immutable: they can only be set once dur", + "ing\\n * construction" + ], + [ + "(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer", + "(address(0), account, amount);\\n\\n _totalSupply " + ], + [ + "information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, includ", + "ing\\n * {IERC20-balanceOf} and {IERC20-transfer" + ], + [ + "information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer", + "}.\\n */\\n function decimals" + ], + [ + "-", + "and-" + ], + [ + "6", + "9" + ], + [ + ":", + "//" + ], + [ + "F", + "RAX" + ], + [ + "c", + "8" + ], + [ + "d", + "ation" + ], + [ + "h", + "op" + ], + [ + "pu", + "bl" + ], + [ + ".\\n *\\n * ", + "Only " + ], + [ + "si", + "g" + ], + [ + "mint", + "er " + ], + [ + "red", + "istribu" + ], + [ + "token ", + "owned by " + ], + [ + "bool ", + "private " + ], + [ + " != ", + "address(0)" + ], + [ + "account ", + "can be " + ], + [ + "Dev", + "elopment" + ], + [ + "token ID", + " " + ], + [ + "result is ", + "negative" + ], + [ + "distribu", + "ted " + ], + [ + "cle", + "an" + ], + [ + "(address(0), account, amount", + ");\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` " + ], + [ + "Royal", + "ties" + ], + [ + "Collection", + " of " + ], + [ + "Found", + "ation" + ], + [ + "a * ", + "b" + ], + [ + "s ", + "previous " + ], + [ + "20", + " " + ], + [ + "account", + ".\\n */\\n function " + ], + [ + "ig", + "no" + ], + [ + "RE", + "CI" + ], + [ + "sto", + "re the " + ], + [ + "uint256) {\\n ", + "// " + ], + [ + "verif", + "y " + ], + [ + "licen", + "s" + ], + [ + "\\\");\\n _", + ";\\n }\\n\\n /**\\n * @dev " + ], + [ + "types ", + "of " + ], + [ + "Delet", + "e" + ], + [ + "\"Transfer ", + "amount must be greater than zero\"" + ], + [ + ");\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender", + ") public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-" + ], + [ + "increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue", + ") public virtual returns (bool) {\\n " + ], + [ + "5` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * ", + "Ether and Wei. This is the " + ], + [ + "RECI", + "SION" + ], + [ + "(", + ");" + ], + [ + ".", + "addr" + ], + [ + "e", + "ach" + ], + [ + "re", + "ward " + ], + [ + "address ", + "clear" + ], + [ + ",\\n ", + "InvalidSignature" + ], + [ + "for ", + "this " + ], + [ + "ter", + "min" + ], + [ + "bytes32", + "[] calldata " + ], + [ + "po", + "t" + ], + [ + "import \\\"", + "./" + ], + [ + "Operator", + "s can call " + ], + [ + "Con", + "si" + ], + [ + "modul", + "o" + ], + [ + "approved ", + "at a time" + ], + [ + "napsh", + "ot " + ], + [ + "`operator", + "` cannot be the caller" + ], + [ + "{transferFrom", + "} or {" + ], + [ + "as an ", + "operator for " + ], + [ + "rede", + "mp" + ], + [ + "a single ", + "account can be " + ], + [ + ", so ", + "approv" + ], + [ + "You ", + "should " + ], + [ + "tokens will be ", + "burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer" + ], + [ + "Approve ", + "or remove " + ], + [ + "https://solidity.readthedocs.io/en/", + "latest/" + ], + [ + "approval is cleared when the token is ", + "transferred" + ], + [ + "for any ", + "token owned by " + ], + [ + "`operator` ", + "as an operator for " + ], + [ + "address clear", + "s previous " + ], + [ + "Operators can call ", + "{transferFrom} or {" + ], + [ + "approved at a time", + ", so approv" + ], + [ + "a single account can be ", + "approved at a time, so approv" + ], + [ + "Approve or remove ", + "`operator` as an operator for " + ], + [ + "for any token owned by ", + "the caller" + ], + [ + "Approve or remove `operator` as an operator for ", + "the caller" + ], + [ + " ", + "been " + ], + [ + ")", + ",\\n * " + ], + [ + "0", + ",\\n " + ], + [ + "N", + "o " + ], + [ + "v", + " " + ], + [ + "er", + "'s " + ], + [ + "ver", + "ifi" + ], + [ + "0000", + "00" + ], + [ + "openzeppelin", + ".com/" + ], + [ + "implementation", + ", " + ], + [ + "(1", + " << " + ], + [ + "Zer", + "o " + ], + [ + "does not ", + "exist" + ], + [ + "Ar", + "tist" + ], + [ + "detail", + "s" + ], + [ + "from` and `to` are never both ", + "zero" + ], + [ + "Remo", + "ved" + ], + [ + "squ", + "are " + ], + [ + "manage all", + " of the " + ], + [ + "security/", + "ReentrancyGuard" + ], + [ + "Blacklist", + "ed" + ], + [ + "inc", + "ip" + ], + [ + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue", + ") public virtual returns (bool) {\\n " + ], + [ + "Consi", + "der " + ], + [ + " ", + "TH" + ], + [ + ")", + ",\\n \\\"" + ], + [ + "`", + "," + ], + [ + "str", + "ict" + ], + [ + ".\\n */\\n function ", + "_transferOwnership(address newOwner" + ], + [ + "Amount", + " = " + ], + [ + "red", + "isFee" + ], + [ + "] ", + "!= " + ], + [ + "Up", + "grad" + ], + [ + "`.", + "\\n * " + ], + [ + "Set", + "AutomatedMarketMakerPair" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `", + "to` cannot be the zero address.\\n * - `" + ], + [ + "Ac", + "tive " + ], + [ + "Pre", + "vent" + ], + [ + "` is allowed to ", + "manage all of the " + ], + [ + "tokens.\\n *\\n * This ", + "internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve" + ], + [ + "iform", + " " + ], + [ + "` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn", + "(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n " + ], + [ + "Returns if the ", + "`operator" + ], + [ + ")) private _allowances;\\n\\n uint256 private _totalSupply", + ";\\n\\n string private _name;\\n string private _symbol" + ], + [ + "` is allowed to manage all of the ", + "assets " + ], + [ + ",", + "\\n// " + ], + [ + "u", + "le" + ], + [ + "{", + "\\r\\n " + ], + [ + "in", + "creases the " + ], + [ + "token", + " to " + ], + [ + "function ", + "that " + ], + [ + "ag", + "es" + ], + [ + "Th", + "ese " + ], + [ + "it ", + "will be " + ], + [ + "li", + "gence" + ], + [ + "{\\n ", + "if (" + ], + [ + "UR", + "POS" + ], + [ + "IN", + "VALID" + ], + [ + "FF", + "SET" + ], + [ + ",\\n address ", + "from" + ], + [ + "Pro", + "xy " + ], + [ + "\\\\", + " " + ], + [ + "E_", + "P" + ], + [ + "gas ", + "limit" + ], + [ + "functions ", + "relat" + ], + [ + "set._", + "indexes[" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.", + "9" + ], + [ + "multipl", + "ication" + ], + [ + "form", + "at" + ], + [ + "{ERC20", + "} " + ], + [ + "].sub(", + "amount, \\\"ERC20: " + ], + [ + ".\\n */\\n function _mint", + "(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply " + ], + [ + "bytes16", + " " + ], + [ + "Sets `amount` as the allowance of `spender` over the `owner` s ", + "tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve" + ], + [ + "Collection of ", + "functions relat" + ], + [ + "Returns if the `operator", + "` is allowed to manage all of the assets " + ], + [ + "Returns if the `operator` is allowed to manage all of the assets ", + "of `owner" + ], + [ + "B", + "URNED" + ], + [ + "s ", + "pattern" + ], + [ + "return", + "s the " + ], + [ + "\\n function ", + "set" + ], + [ + "wh", + "o" + ], + [ + "Ma", + "in" + ], + [ + "\\n * - `", + "from` and `to` are never both zero" + ], + [ + " is ", + "transferred to " + ], + [ + "abi", + "-encod" + ], + [ + "mod", + "ify" + ], + [ + "ig", + "h " + ], + [ + "On", + "ly" + ], + [ + ".\\n * ", + "Operators can call {transferFrom} or {" + ], + [ + "interface ", + "ID" + ], + [ + "must be ", + "owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this " + ], + [ + "\\n * ", + "@return " + ], + [ + "ApprovalForAll", + "} event.\\n */\\n function " + ], + [ + "account ", + "approved for " + ], + [ + "owner ", + "|| " + ], + [ + ", bytes32 ", + "r" + ], + [ + "/// @", + "author " + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - The ", + "caller must own the token or be an approved operator" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - The ", + "`operator` cannot be the caller" + ], + [ + "work", + " " + ], + [ + "stop", + "-" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token ", + "must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this " + ], + [ + "under ", + "the " + ], + [ + "BITPOS_NUMBER_", + "BURNED" + ], + [ + ".\\n * The ", + "approval is cleared when the token is transferred" + ], + [ + "Get ", + "the " + ], + [ + "Internal function without access restriction", + ".\\n */\\n function _transferOwnership(address newOwner" + ], + [ + "cons", + "en" + ], + [ + ".\\n *\\n * Emits an {", + "ApprovalForAll} event.\\n */\\n function " + ], + [ + "_COMP", + "LEMENT" + ], + [ + "Gives permission to `to` to transfer `tokenId` token to another account", + ".\\n * The approval is cleared when the token is transferred" + ], + [ + ".\\n *\\n * Only ", + "a single account can be approved at a time, so approv" + ], + [ + "address clears previous ", + "approvals" + ], + [ + "for any token owned by the caller", + ".\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller" + ], + [ + "Approve or remove `operator` as an operator for the caller", + ".\\n * Operators can call {transferFrom} or {" + ], + [ + "Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred", + ".\\n *\\n * Only a single account can be approved at a time, so approv" + ], + [ + "f", + "a" + ], + [ + "w", + "ar" + ], + [ + "y", + "Index" + ], + [ + "is ", + "already " + ], + [ + "a ", + "different " + ], + [ + "us", + "d" + ], + [ + "su", + "re " + ], + [ + "20", + "19" + ], + [ + "s.", + "net" + ], + [ + "(\\n address ", + "token" + ], + [ + "hash", + "TypedDataV4" + ], + [ + "col", + "lateral " + ], + [ + "pair", + " " + ], + [ + "gas ", + "and " + ], + [ + "Upgrade", + "able " + ], + [ + ",\\n ", + "address " + ], + [ + "never", + " " + ], + [ + "control", + " is transferred to " + ], + [ + "variabl", + "es." + ], + [ + "removeLiquidityETH", + "WithPermit" + ], + [ + "integer ", + "division" + ], + [ + "(address payable ", + "recipient, uint256 amount" + ], + [ + "isContract(address account", + ") internal view returns (bool" + ], + [ + ", bytes32 r", + ", bytes32 " + ], + [ + ".\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function ", + "setApprovalForAll(address operator" + ], + [ + "(", + "amount" + ], + [ + "I", + "ENT" + ], + [ + "P", + "ending" + ], + [ + "R", + "U" + ], + [ + "un", + "its" + ], + [ + "ar", + "t" + ], + [ + "\\n ", + "assembly {\\n " + ], + [ + "sy", + "s.net" + ], + [ + ") {\\n ", + "require(" + ], + [ + "Ident", + "ifier " + ], + [ + "send", + "s `amount` " + ], + [ + "sel", + "ect " + ], + [ + "will be ", + "created" + ], + [ + "use", + "s a `" + ], + [ + "revert reason ", + "and " + ], + [ + "sale", + "Price" + ], + [ + "math/", + "SafeMath" + ], + [ + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../", + "utils/Context.sol\\\";\\n\\n/**\\n * @dev " + ], + [ + "security", + "-" + ], + [ + " bit", + "s, " + ], + [ + "in the set. O(1", + ").\\n */\\n function " + ], + [ + "conver", + "t to " + ], + [ + "(bool success, ) = ", + "recipient" + ], + [ + "(uint256 a, uint256 b, string memory errorMessage", + ") internal pure returns (uint256) {\\n " + ], + [ + "concat", + "en" + ], + [ + "For a generic mechanism see {ERC20PresetMinterPauser", + "}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum." + ], + [ + "Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * ", + "For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum." + ], + [ + "consider", + "ation" + ], + [ + "account.\\n */\\n function ", + "balanceOf(address owner" + ], + [ + "Delete", + "Index" + ], + [ + "consen", + "sys.net" + ], + [ + "uses a `", + "revert" + ], + [ + "%", + "` operator" + ], + [ + ".", + "onERC721Received.selector" + ], + [ + "/", + "` operator" + ], + [ + "I", + "ERC2981" + ], + [ + "s", + "store" + ], + [ + ", ", + "use {" + ], + [ + ") ", + "and not " + ], + [ + "@dev ", + "Returns the " + ], + [ + "no", + "-in" + ], + [ + "return ", + "false " + ], + [ + "decim", + "al " + ], + [ + "s[", + "owner" + ], + [ + "URI", + ") " + ], + [ + "Max", + "Supply" + ], + [ + "Pro", + "cess" + ], + [ + "line", + "-assembly" + ], + [ + ";\\n\\n /**\\n * @dev ", + "Sets the values for {name} and {symbol" + ], + [ + "Solidity ", + "uses " + ], + [ + "AD", + "esired" + ], + [ + "] += ", + "amount" + ], + [ + "enum", + " " + ], + [ + "` must be ", + "a contract" + ], + [ + "ers ", + "can " + ], + [ + "pause", + "(" + ], + [ + "making ", + "them " + ], + [ + ");\\n }\\n\\n /**\\n * @dev See {IERC721-", + "safeTransferFrom" + ], + [ + "domainSeparator", + "V4" + ], + [ + "QU", + "ID" + ], + [ + "opcode (which leaves remaining gas untouched) while ", + "Solidity uses " + ], + [ + "division by zero", + ". The result is rounded toward" + ], + [ + ". This function ", + "uses a `revert" + ], + [ + "go ", + "over the " + ], + [ + "`.\\n *\\n * See {", + "setApprovalForAll" + ], + [ + "%` operator", + ". This function uses a `revert" + ], + [ + "no-in", + "line-assembly" + ], + [ + "division by zero. The result is rounded toward", + "s " + ], + [ + "0", + "\"" + ], + [ + "h", + "igh " + ], + [ + "n", + "ow " + ], + [ + "}", + ".\\n *\\n * Emits a {Transfer} event.\\n */\\n function " + ], + [ + "` ", + "array" + ], + [ + "of ", + "an " + ], + [ + "sh", + "if" + ], + [ + ". ", + "Consider " + ], + [ + "the", + "-" + ], + [ + "utils/", + "cryptography/" + ], + [ + ".\\n * - `", + "tokenId` must exist" + ], + [ + " <", + "< _" + ], + [ + "`tokenId` ", + "will be\\n * " + ], + [ + "must be ", + "`" + ], + [ + "denominator", + ") " + ], + [ + "IM", + "UM" + ], + [ + "uint256 public ", + "constant " + ], + [ + "tokenB", + "yIndex" + ], + [ + "by", + "\\n * " + ], + [ + ".\\n *\\n * Emits an {Approval", + "} event.\\n */\\n function " + ], + [ + "();\\n\\n /**\\n * ", + "Cannot " + ], + [ + ").interfaceId ", + "||\\n " + ], + [ + "registe", + "red" + ], + [ + "_exists(tokenId", + "), \\\"ERC721: " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * ", + "Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner" + ], + [ + "owner of the ", + "`tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function " + ], + [ + "global", + "-" + ], + [ + "();\\n\\n /**\\n * The ", + "token " + ], + [ + "`tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ", + "getApproved" + ], + [ + "minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s ", + "tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer" + ], + [ + "transferred to `to`.\\n * - When `from", + "` is zero, `tokenId` will be " + ], + [ + "WITH", + "OUT " + ], + [ + "\\u003e", + "= " + ], + [ + "Ear", + "ly" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6", + ".0) (" + ], + [ + "transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be ", + "minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer" + ], + [ + "applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it ", + "isn't " + ], + [ + "(account, address(0), amount);\\n }\\n\\n /**\\n * @dev ", + "Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve" + ], + [ + "publ", + "ish" + ], + [ + "strict", + "ly " + ], + [ + "Returns if the `operator` is allowed to manage all of the assets of `owner", + "`.\\n *\\n * See {setApprovalForAll" + ], + [ + "account approved for ", + "`tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved" + ], + [ + "for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller", + ".\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator" + ], + [ + "`tokenId` will be\\n * ", + "transferred to `to`.\\n * - When `from` is zero, `tokenId` will be " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner", + ") internal virtual {\\n " + ], + [ + "owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ", + "ownerOf" + ], + [ + "(", + "unsigned integer " + ], + [ + "(", + "URI) " + ], + [ + "H", + "ANT" + ], + [ + "M", + "ERC" + ], + [ + "x", + "C" + ], + [ + "re", + "fund" + ], + [ + "uint256", + ") {\\r\\n return " + ], + [ + "to ", + "assume that " + ], + [ + "721", + " " + ], + [ + "ERC721", + "Metadata" + ], + [ + "Am", + "ong " + ], + [ + "li", + "ved" + ], + [ + "address(", + "uint160(" + ], + [ + ", \\\"", + "\\\"" + ], + [ + "Un", + "iform " + ], + [ + "using ", + "memory " + ], + [ + "use", + "-" + ], + [ + "Res", + "ource " + ], + [ + "ERC721A", + "__" + ], + [ + "St", + "able" + ], + [ + "was ", + "destroy" + ], + [ + " from ", + "int256, reverting on\\n * overflow (when the input is less than smallest " + ], + [ + "account (", + "EOA" + ], + [ + "other", + "s, " + ], + [ + ", but ", + "was destroy" + ], + [ + "As", + "set " + ], + [ + "a contract ", + "in construction" + ], + [ + "MINT", + "ER_ROLE" + ], + [ + "--------------------------------", + "--------------------------------" + ], + [ + "sendValue", + "(address payable recipient, uint256 amount" + ], + [ + "fals", + "e is " + ], + [ + "Lea", + "rn " + ], + [ + "Hook that is called before ", + "any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * " + ], + [ + "unsafe ", + "to assume that " + ], + [ + "It is ", + "unsafe to assume that " + ], + [ + "an externally-owned ", + "account" + ], + [ + "unable to send value, recipient may have ", + "reverted" + ], + [ + "Equivalent to ", + "`" + ], + [ + "ers. ", + "(unsigned integer " + ], + [ + "remainder of dividing two unsigned integ", + "ers. (unsigned integer " + ], + [ + "NE", + "SS" + ], + [ + "square ", + "root " + ], + [ + "security-", + "consideration" + ], + [ + "Among ", + "others, " + ], + [ + "lived", + ", but was destroy" + ], + [ + "Uniform ", + "Resource " + ], + [ + "account (EOA", + ") and not " + ], + [ + "Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * ", + "will be " + ], + [ + "It is unsafe to assume that ", + "an address " + ], + [ + "remainder of dividing two unsigned integers. (unsigned integer ", + "modulo" + ], + [ + "-", + "now" + ], + [ + "/", + "09" + ], + [ + "/", + "stop-" + ], + [ + "[", + "checks-effects-interaction" + ], + [ + "m", + "ate" + ], + [ + "{", + "sendValue" + ], + [ + ") ", + "< " + ], + [ + "ed ", + "up " + ], + [ + ": ", + "use " + ], + [ + "Id", + "x" + ], + [ + "transfer", + "`, " + ], + [ + "transfer", + "`. " + ], + [ + "transfer", + "`: " + ], + [ + "transfer", + "-now" + ], + [ + "st", + "ash" + ], + [ + "} ", + "remove" + ], + [ + "di", + "ligence" + ], + [ + "IT", + "NESS" + ], + [ + "This ", + "function is " + ], + [ + "burn", + "From" + ], + [ + "+ ", + "amount" + ], + [ + "s, ", + "possibly " + ], + [ + "s-", + "pattern" + ], + [ + "s-", + "transfer-now" + ], + [ + "Po", + "d" + ], + [ + "https://eips.ethereum.org/EIPS/eip-", + "1884" + ], + [ + "reverting ", + "on error" + ], + [ + ".sol\\\";\\n\\n/**\\n * @dev ", + "Interface for the " + ], + [ + "\\n //", + "/" + ], + [ + "solidity", + "s-transfer-now" + ], + [ + "this function ", + "returns" + ], + [ + "writ", + "t" + ], + [ + "available ", + "gas and " + ], + [ + "wei", + " to" + ], + [ + "because ", + "it " + ], + [ + "because ", + "control is transferred to " + ], + [ + "[EIP", + "1884" + ], + [ + "contracts ", + "go over the " + ], + [ + "ReentrancyGuard", + "} or " + ], + [ + "using-", + "soliditys-transfer-now" + ], + [ + "uint112", + " " + ], + [ + "ing all ", + "available gas and " + ], + [ + "23", + "00 " + ], + [ + "Solidity function ", + "call" + ], + [ + "impos", + "ed by `" + ], + [ + "Mod", + "ifier " + ], + [ + "unable to ", + "receive " + ], + [ + "making ", + "contracts go over the " + ], + [ + "certain ", + "opcode" + ], + [ + "an externally-owned ", + "account (EOA) and not " + ], + [ + "checks-effects-interaction", + "s-pattern" + ], + [ + "forward", + "ing all available gas and " + ], + [ + "create ", + "reentrancy vulner" + ], + [ + "s this ", + "limit" + ], + [ + "/[", + "Learn " + ], + [ + "s.html#", + "use-" + ], + [ + "funds ", + "vi" + ], + [ + "Replac", + "ement for " + ], + [ + "for which ", + "this function returns" + ], + [ + " ? a : ", + "b;\\n }\\n\\n /**\\n * @dev Returns the " + ], + [ + "abilities", + ". Consider " + ], + [ + "taken to not ", + "create reentrancy vulner" + ], + [ + "`recipient`, ", + "care " + ], + [ + "`isContract` will ", + "return false " + ], + [ + "(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` ", + "set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account" + ], + [ + "types of ", + "addresses" + ], + [ + "increases the ", + "gas cost" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator", + ".\\n * - `tokenId` must exist" + ], + [ + "address clears previous approvals", + ".\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist" + ], + [ + "2019", + "/09" + ], + [ + "Identifier ", + "(URI) " + ], + [ + "sends `amount` ", + "wei to" + ], + [ + "consensys.net", + "/" + ], + [ + "making them ", + "unable to receive " + ], + [ + "the-", + "checks-effects-interactions-pattern" + ], + [ + "applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't ", + "required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract " + ], + [ + "false is ", + "an externally-owned account (EOA) and not " + ], + [ + "security-consideration", + "s.html#use-" + ], + [ + "Among others, ", + "`isContract` will return false " + ], + [ + "Uniform Resource ", + "Identifier (URI) " + ], + [ + "It is unsafe to assume that an address ", + "for which this function returns" + ], + [ + "/stop-", + "using-soliditys-transfer-now" + ], + [ + "[checks-effects-interaction", + "s pattern" + ], + [ + "{sendValue", + "} remove" + ], + [ + "transfer`, ", + "making them unable to receive " + ], + [ + "transfer`. ", + "{sendValue} remove" + ], + [ + "transfer`: ", + "sends `amount` wei to" + ], + [ + "s, possibly ", + "making contracts go over the " + ], + [ + "because control is transferred to ", + "`recipient`, care " + ], + [ + "2300 ", + "gas limit" + ], + [ + "imposed by `", + "transfer`, making them unable to receive " + ], + [ + "certain opcode", + "s, possibly making contracts go over the " + ], + [ + "forwarding all available gas and ", + "reverting on error" + ], + [ + "/[Learn ", + "more" + ], + [ + "abilities. Consider ", + "using" + ], + [ + "taken to not create reentrancy vulner", + "abilities. Consider using" + ], + [ + "2019/09", + "/stop-using-soliditys-transfer-now" + ], + [ + "the-checks-effects-interactions-pattern", + "[checks-effects-interactions pattern" + ], + [ + "security-considerations.html#use-", + "the-checks-effects-interactions-pattern[checks-effects-interactions pattern" + ], + [ + "Among others, `isContract` will return false ", + "for the " + ], + [ + "transfer`. {sendValue} remove", + "s this limit" + ], + [ + "imposed by `transfer`, making them unable to receive ", + "funds vi" + ], + [ + "certain opcodes, possibly making contracts go over the ", + "2300 gas limit" + ], + [ + "2019/09/stop-using-soliditys-transfer-now", + "/[Learn more" + ], + [ + "(", + "like " + ], + [ + "F", + "ree " + ], + [ + "S", + "wa" + ], + [ + "[", + "prod1 " + ], + [ + "d", + "ou" + ], + [ + "e", + "6" + ], + [ + "g", + "o" + ], + [ + "m", + "c" + ], + [ + "o", + "g" + ], + [ + ", ", + "prod0" + ], + [ + "address ", + "type" + ], + [ + ".\\n */\\n function ", + "tokenURI" + ], + [ + ",\\n ", + "address[] calldata path" + ], + [ + "), ", + "returndata_size" + ], + [ + "pro", + "vides " + ], + [ + "All", + "Tokens" + ], + [ + "red", + "is" + ], + [ + "] ", + "increases the gas cost" + ], + [ + "Returns the ", + "raw " + ], + [ + ", \\\"", + "ERC721: " + ], + [ + "License", + ", " + ], + [ + "http", + "://" + ], + [ + "`, ", + "checking first that contract recipient" + ], + [ + "18", + " " + ], + [ + "ap", + "i/" + ], + [ + "sel", + "f " + ], + [ + "may ", + "not " + ], + [ + "][", + "msg.sender" + ], + [ + "_burn", + "Counter " + ], + [ + "\\r\\n ", + "/**" + ], + [ + "IC", + "UL" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.", + "5" + ], + [ + "let ", + "returndata_" + ], + [ + "mload(", + "returndata" + ], + [ + "high", + "light" + ], + [ + "ed to the ", + "address type" + ], + [ + ");\\n }\\n\\n ", + "return true;\\n }\\n\\n /**\\n * @dev " + ], + [ + "_totalSupply ", + "-= " + ], + [ + "No", + "Error" + ], + [ + "the calling ", + "contract " + ], + [ + "revert(add(32, ", + "returndata" + ], + [ + " to prevent ", + "tokens from being forever locked" + ], + [ + "aware of the ERC721 protocol", + " to prevent tokens from being forever locked" + ], + [ + "Collection of functions relat", + "ed to the address type" + ], + [ + "`tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be ", + "minted for `to`.\\n * - When `to" + ], + [ + "https://eips.ethereum.org/EIPS/eip-1884", + "[EIP1884" + ], + [ + "[prod1 ", + "prod0" + ], + [ + "ICUL", + "AR" + ], + [ + "let returndata_", + "size := " + ], + [ + "https://eips.ethereum.org/EIPS/eip-1884[EIP1884", + "] increases the gas cost" + ], + [ + ")", + "\\n // " + ], + [ + "ad", + "e " + ], + [ + "uint", + " _" + ], + [ + "de", + "sign" + ], + [ + "an ", + "ETH " + ], + [ + ") internal pure returns (", + "string memory) {\\n " + ], + [ + "e the ", + "revert reason is " + ], + [ + "Set", + "ting" + ], + [ + " for ", + "revert reason and " + ], + [ + "To ", + "convert to " + ], + [ + "https://eips.ethereum.org/EIPS/eip-", + "712" + ], + [ + "Allow", + "List" + ], + [ + "via ", + "assembly" + ], + [ + "A ", + "PART" + ], + [ + "Rem", + "ain" + ], + [ + "up ", + "if present" + ], + [ + "_currentIndex", + " - " + ], + [ + "wei", + " to " + ], + [ + "pow", + "er of " + ], + [ + "with `", + "data` " + ], + [ + "bubbl", + "e it " + ], + [ + "bubbl", + "e the revert reason is " + ], + [ + "off", + "-" + ], + [ + "_add", + "TokenTo" + ], + [ + "easi", + "est way to " + ], + [ + "Look", + " for revert reason and " + ], + [ + "HA", + "IN" + ], + [ + " P", + "URPOS" + ], + [ + " FOR ", + "A PART" + ], + [ + "_SIGN", + "ATUR" + ], + [ + "_transferOwnership(newOwner", + ");\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n " + ], + [ + "QUID", + "ITY" + ], + [ + "HANT", + "ABILITY" + ], + [ + "MERC", + "HANTABILITY" + ], + [ + "using memory ", + "via assembly" + ], + [ + "ed up ", + "by " + ], + [ + "ITNESS", + " FOR A PART" + ], + [ + "revert(add(32, returndata", + "), returndata_size" + ], + [ + "let returndata_size := ", + "mload(returndata" + ], + [ + "bubble it ", + "up if present" + ], + [ + "bubble the revert reason is ", + "using memory via assembly" + ], + [ + "easiest way to ", + "bubble the revert reason is using memory via assembly" + ], + [ + "Look for revert reason and ", + "bubble it up if present" + ], + [ + "ITNESS FOR A PART", + "ICULAR" + ], + [ + "\"", + "Must " + ], + [ + "#", + "abi-encod" + ], + [ + "(", + "), \\\"" + ], + [ + "-", + "uint256-}[`" + ], + [ + "=", + "abi.decode" + ], + [ + "?", + "highlight" + ], + [ + "_", + "wallet" + ], + [ + "`", + "call" + ], + [ + "`", + "abi.decode" + ], + [ + "function", + "s[" + ], + [ + "ed ", + "Solidity function " + ], + [ + "ri", + "ght " + ], + [ + "us", + "es, " + ], + [ + "byt", + "e " + ], + [ + "call", + "`. A" + ], + [ + "- ", + "subtractedValue" + ], + [ + ",\\n ", + "bytes memory returndata" + ], + [ + "ator", + " " + ], + [ + "{\\n ", + "address " + ], + [ + "recipient", + "` cannot be the zero address.\\n * - `" + ], + [ + "must ", + "not revert" + ], + [ + "num", + "Checkpoint" + ], + [ + "target", + "` must be a contract" + ], + [ + "the call", + "ed Solidity function " + ], + [ + "sell", + "Fee" + ], + [ + "Pool", + "'s " + ], + [ + "ownership", + ".\\n uint256 private constant _" + ], + [ + "call ", + "using a " + ], + [ + "use ", + "https://solidity.readthedocs.io/en/latest/" + ], + [ + "must have ", + "an ETH " + ], + [ + "\\n * `", + "recipient" + ], + [ + "level", + " `" + ], + [ + "functionCallWithValue", + "-address-bytes" + ], + [ + "functionCallWithValue", + "`], " + ], + [ + "_set", + "RoleAdmin" + ], + [ + "also ", + "transferring " + ], + [ + "-}[`functionCall`]", + ", but " + ], + [ + "`value` ", + "wei to " + ], + [ + "balance of at least ", + "`value" + ], + [ + "`target` ", + "with `data` " + ], + [ + "bubbl", + "ed up by " + ], + [ + "data. ", + "To convert to " + ], + [ + "calling ", + "`target` with `data` " + ], + [ + "returned ", + "data. To convert to " + ], + [ + "Solidity function ", + "call using a " + ], + [ + "`target` revert", + "s with a " + ], + [ + "html", + "?highlight" + ], + [ + "low ", + "level `" + ], + [ + "ing-", + "and-" + ], + [ + "ing-", + "functions[" + ], + [ + "unsafe ", + "replac" + ], + [ + "the expected ", + "return value" + ], + [ + "ement for ", + "a function call" + ], + [ + "revert reason", + ", it is " + ], + [ + "regular ", + "Solidity function call" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7", + ".0) (" + ], + [ + "` is an ", + "unsafe replac" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - the caller must have ", + "``role``'s admin role" + ], + [ + "decod", + "ing-functions[" + ], + [ + "Performs a ", + "Solidity function call using a " + ], + [ + "-and-", + "global-" + ], + [ + "variables.", + "html?highlight" + ], + [ + "units", + "-and-global-" + ], + [ + "must be `", + "payable" + ], + [ + "(like ", + "regular Solidity function call" + ], + [ + "Returns the raw ", + "returned data. To convert to " + ], + [ + "the calling contract ", + "must have an ETH " + ], + [ + "#abi-encod", + "ing-and-" + ], + [ + "-uint256-}[`", + "functionCallWithValue`], " + ], + [ + "=abi.decode", + "#abi-encoding-and-" + ], + [ + "`call", + "` is an unsafe replac" + ], + [ + "recipient` cannot be the zero address.\\n * - `", + "sender` must have a balance of at least `amount" + ], + [ + "the called Solidity function ", + "must be `payable" + ], + [ + "use https://solidity.readthedocs.io/en/latest/", + "units-and-global-" + ], + [ + "functionCallWithValue-address-bytes", + "-uint256-}[`functionCallWithValue`], " + ], + [ + "also transferring ", + "`value` wei to " + ], + [ + "calling `target` with `data` ", + "must not revert" + ], + [ + "`target` reverts with a ", + "revert reason, it is " + ], + [ + "low level `", + "call`. A" + ], + [ + "ement for a function call", + ": use " + ], + [ + "decoding-functions[", + "`abi.decode" + ], + [ + "Performs a Solidity function call using a ", + "low level `call`. A" + ], + [ + "variables.html?highlight", + "=abi.decode#abi-encoding-and-" + ], + [ + "Returns the raw returned data. To convert to ", + "the expected return value" + ], + [ + "the calling contract must have an ETH ", + "balance of at least `value" + ], + [ + "`call` is an unsafe replac", + "ement for a function call: use " + ], + [ + "use https://solidity.readthedocs.io/en/latest/units-and-global-", + "variables.html?highlight=abi.decode#abi-encoding-and-" + ], + [ + "functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], ", + "bu" + ], + [ + "also transferring `value` wei to ", + "`target" + ], + [ + "`target` reverts with a revert reason, it is ", + "bubbled up by " + ], + [ + "use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-", + "decoding-functions[`abi.decode" + ], + [ + "F", + "ITNESS FOR A PARTICULAR" + ], + [ + "t", + "ree " + ], + [ + "amount", + "\\n ) external " + ], + [ + "address ", + "pair" + ], + [ + "from ", + "!= address(0), \\\"" + ], + [ + ");\\n\\n ", + "/// @dev " + ], + [ + "revert ", + "TransferToNonERC721ReceiverImplementer" + ], + [ + "\\\");\\n\\n ", + "// " + ], + [ + "\"@openzeppelin/contracts/", + "access/Ownable.sol\"" + ], + [ + " bits", + "\"" + ], + [ + "_get", + "Values" + ], + [ + "es[role].", + "member" + ], + [ + "modulo ", + "by " + ], + [ + ";\\n }\\n\\n /**\\n * @dev See {IERC721Metadata", + "-" + ], + [ + "keccak256(abi.encodePacked(\\\"", + "\\\\x19" + ], + [ + ".\\n *\\n * Emits an {Approval} event.\\n */\\n function ", + "approve(address to, uint256 tokenId" + ], + [ + "address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist", + ".\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId" + ], + [ + "FITNESS FOR A PARTICULAR", + " PURPOS" + ], + [ + "9", + "1" + ], + [ + "e", + "poch" + ], + [ + "r", + "Team" + ], + [ + "an", + "bul" + ], + [ + "as", + "ter" + ], + [ + "\\n * ", + "}\\n * ```\\n *\\n * " + ], + [ + "at ", + "`" + ], + [ + "from ", + "!= " + ], + [ + "] ", + "-= " + ], + [ + "Swap", + "Back" + ], + [ + "data ", + "to " + ], + [ + "support", + "ed" + ], + [ + "last", + "Index" + ], + [ + ") public virtual override ", + "{\\n require(" + ], + [ + "_afterTokenTransfer", + "s" + ], + [ + "ERC20 ", + "standard" + ], + [ + "isApproved", + "OrOwner" + ], + [ + "revert(", + "errorMessage" + ], + [ + ".sol\\\";\\nimport \\\"./", + "extensions/" + ], + [ + ")\\n ", + "}\\n " + ], + [ + "_marketing", + "Address" + ], + [ + ") public virtual override returns (bool) {\\n ", + "_transfer" + ], + [ + "Data ", + "= " + ], + [ + "write", + "Checkpoint" + ], + [ + "@openzeppelin/contracts-", + "upgradeable/" + ], + [ + "call with value failed", + "\\\"" + ], + [ + "OpenZeppelin", + "/" + ], + [ + "s\\n * are ", + "aware of the ERC721 protocol to prevent tokens from being forever locked" + ], + [ + "Address for ", + "address" + ], + [ + "war", + "rant" + ], + [ + ");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom", + "}.\\n */\\n function " + ], + [ + "`, checking first that contract recipient", + "s\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked" + ], + [ + "uses, ", + "unless " + ], + [ + " ", + "address" + ], + [ + ")", + ") revert " + ], + [ + "@", + "balancer-labs/v2-" + ], + [ + "F", + "ree" + ], + [ + "b", + "id" + ], + [ + "ar", + "bitrary " + ], + [ + "account", + "s that " + ], + [ + "account", + "Balance = " + ], + [ + "sp", + "ent " + ], + [ + ", uint256 ", + "_amount" + ], + [ + "The ", + "amount of " + ], + [ + "Ownership", + "Addr" + ], + [ + "totalSupply", + "() " + ], + [ + "au", + "ction" + ], + [ + "\\n */", + "\\r\\n" + ], + [ + "interface ", + "id " + ], + [ + "Buy", + "Amount" + ], + [ + ".length", + " - 1" + ], + [ + ";\\n\\n ", + "emit " + ], + [ + "&& ", + "!" + ], + [ + "tive", + "Reserve" + ], + [ + ", \\\"Address: ", + "unable to send value, recipient may have reverted" + ], + [ + "has", + "Role(" + ], + [ + "mstore", + "8" + ], + [ + "https://github.com/", + "OpenZeppelin/" + ], + [ + "curr", + "OwnershipAddr" + ], + [ + "ffffffffffffffff", + "ffffffffffffffff" + ], + [ + "token/ERC20/IERC20", + ".sol\"" + ], + [ + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n ", + "// " + ], + [ + ", \\\"Address: insufficient ", + "balance" + ], + [ + "1,\\n ", + "1,\\n " + ], + [ + "a", + "8" + ], + [ + "e", + "b" + ], + [ + "To", + "ol" + ], + [ + "for ", + "`tokenId` token" + ], + [ + "value ", + "{ERC20} " + ], + [ + "10", + "))" + ], + [ + "only ", + "stored " + ], + [ + "recei", + "ve the " + ], + [ + "LE", + "G" + ], + [ + "hold", + "er " + ], + [ + "signature", + "s " + ], + [ + "_T", + "RA" + ], + [ + "lp", + "Burn" + ], + [ + "you ", + "should " + ], + [ + ", which ", + "returns " + ], + [ + "address owner = ", + "ERC721.ownerOf(tokenId" + ], + [ + "Multi", + "Proof" + ], + [ + "QueryFor", + "ZeroAddress" + ], + [ + "Grant", + "s `role" + ], + [ + "Pres", + "ale" + ], + [ + "(address from, address ", + "to, uint256 " + ], + [ + ".\\n *\\n * _Available since v4.", + "3._\\n */\\n function " + ], + [ + "token collection ", + "name" + ], + [ + "token collection ", + "symbol" + ], + [ + "constructor ", + "execution" + ], + [ + ");\\n\\n // Clear approval", + "s from the previous owner" + ], + [ + "benefici", + "ary" + ], + [ + "code is ", + "only stored " + ], + [ + "This method ", + "relies " + ], + [ + ", since the ", + "code is only stored " + ], + [ + "redistribu", + "t" + ], + [ + "(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account", + "` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n " + ], + [ + "Uniform Resource Identifier (URI) ", + "for `tokenId` token" + ], + [ + "value {ERC20} ", + "uses, unless " + ], + [ + ", which returns ", + "0" + ], + [ + "Grants `role", + "` to " + ], + [ + ", since the code is only stored ", + "at the end" + ], + [ + ".", + "delegatecall" + ], + [ + "]", + ".\\n *\\n * IMPORTANT: " + ], + [ + "_", + "h" + ], + [ + "_", + "price" + ], + [ + "_", + "editionId" + ], + [ + "c", + "app" + ], + [ + "u", + "al " + ], + [ + "\\n ", + "event " + ], + [ + "un", + "k" + ], + [ + "\\n * ", + "imposed by `transfer`, making them unable to receive funds vi" + ], + [ + "to ", + "== address(0)" + ], + [ + "uint256 ", + "accountBalance = " + ], + [ + "ma", + "int" + ], + [ + "ERC20", + ", " + ], + [ + "value", + ", \\\"Address: low-level " + ], + [ + ") {\\n ", + "if (" + ], + [ + "ation ", + "with " + ], + [ + "`, ", + "the " + ], + [ + "`, ", + "forwarding all available gas and reverting on error" + ], + [ + "set ", + "the " + ], + [ + "any ", + "other " + ], + [ + "the\\n * ", + "https://solidity.readthedocs.io/en/" + ], + [ + "(address(0), ", + "RecoverError.InvalidSignature" + ], + [ + "afterTokenTransfer", + "s" + ], + [ + "signature ", + "is " + ], + [ + "admin ", + "role " + ], + [ + "encod", + "ing " + ], + [ + ") {\\n return ", + "returndata;\\n } else {" + ], + [ + "(to, ", + "quantity" + ], + [ + "\\n * {", + "ReentrancyGuard} or " + ], + [ + "process", + "MultiProof" + ], + [ + ">= amount, \\\"ERC20: ", + "burn " + ], + [ + "} else if (", + "error == " + ], + [ + "comm", + "un" + ], + [ + "a\\n * `", + "transfer`. {sendValue} removes this limit" + ], + [ + "address(this).balance ", + ">= amount" + ], + [ + ", \\\"Address: insufficient ", + "balance for call" + ], + [ + "ERC-", + "721 " + ], + [ + "Dec", + "re" + ], + [ + "\\n * of ", + "certain opcodes, possibly making contracts go over the 2300 gas limit" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=", + "0.6.0 <0.8.0" + ], + [ + "must be\\n * ", + "taken to not create reentrancy vulnerabilities. Consider using" + ], + [ + "].\\n */\\n function ", + "sendValue(address payable recipient, uint256 amount" + ], + [ + "ation.\\n *\\n * ", + "https://" + ], + [ + "\\\\xe3\\\\x81", + "\\\\x" + ], + [ + "in case ", + "of " + ], + [ + "s[owner", + "][operator" + ], + [ + "transfer`: sends `amount` wei to", + "\\n * `recipient" + ], + [ + "because control is transferred to `recipient`, care ", + "must be\\n * taken to not create reentrancy vulnerabilities. Consider using" + ], + [ + "security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern", + "].\\n */\\n function sendValue(address payable recipient, uint256 amount" + ], + [ + "2019/09/stop-using-soliditys-transfer-now/[Learn more", + "].\\n *\\n * IMPORTANT: " + ], + [ + "Collection of functions related to the address type", + "\\n */\\nlibrary " + ], + [ + "\\n * imposed by `transfer`, making them unable to receive funds vi", + "a\\n * `transfer`. {sendValue} removes this limit" + ], + [ + "value, \\\"Address: low-level ", + "call with value failed\\\"" + ], + [ + "`, forwarding all available gas and reverting on error", + "s.\\n *\\n * " + ], + [ + "\\n * {ReentrancyGuard} or ", + "the\\n * https://solidity.readthedocs.io/en/" + ], + [ + "} else if (error == ", + "RecoverError.InvalidSignature" + ], + [ + "\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit", + "\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limit" + ], + [ + "transfer`: sends `amount` wei to\\n * `recipient", + "`, forwarding all available gas and reverting on errors.\\n *\\n * " + ], + [ + "because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using", + "\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/" + ], + [ + "2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: ", + "because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/" + ], + [ + "\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limit", + "ation.\\n *\\n * https://" + ], + [ + "P", + "RIC" + ], + [ + "T", + "ow" + ], + [ + "U", + "se " + ], + [ + "\\n * ", + "pl" + ], + [ + "\\n * ", + "false is an externally-owned account (EOA) and not " + ], + [ + "co", + "old" + ], + [ + "/**", + "\\r" + ], + [ + "Si", + "g" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `", + "target` must be a contract" + ], + [ + "Sell", + "Amount" + ], + [ + "`.\\n * - ", + "the called Solidity function must be `payable" + ], + [ + ",\\n * ", + "use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode" + ], + [ + "`]", + ".\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract" + ], + [ + "version", + "." + ], + [ + ");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-", + "functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], bu" + ], + [ + ",\\n ", + "_" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes", + "-}[`functionCall`],\\n * but " + ], + [ + "currentAllowance ", + ">= " + ], + [ + "instead", + ".\\n *\\n * If " + ], + [ + "14", + "4" + ], + [ + "amount;\\n ", + "}\\n\\n emit Transfer" + ], + [ + ").\\n *\\n * Counterpart to Solidity's `", + "int" + ], + [ + ".\\n * - ", + "calling `target` with `data` must not revert" + ], + [ + "Royal", + "ty " + ], + [ + "this\\n * function ", + "(like regular Solidity function call" + ], + [ + "this\\n * function ", + "instead.\\n *\\n * If " + ], + [ + "(data);\\n return verifyCallResult(success, returndata, errorMessage", + ");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes" + ], + [ + "`.\\n *\\n * Requirements:\\n *\\n * - ", + "the calling contract must have an ETH balance of at least `value" + ], + [ + "Ol", + "d" + ], + [ + "s).\\n *\\n * ", + "Returns the raw returned data. To convert to the expected return value" + ], + [ + "\\n * greater than largest ", + "int" + ], + [ + "isContract(address account) internal view returns (bool", + ") {\\n // " + ], + [ + "It is unsafe to assume that an address for which this function returns", + "\\n * false is an externally-owned account (EOA) and not " + ], + [ + "Among others, `isContract` will return false for the ", + "following\\n * " + ], + [ + "https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost", + "\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://" + ], + [ + ",\\n bytes memory returndata", + ",\\n string memory errorMessage\\n " + ], + [ + "Performs a Solidity function call using a low level `call`. A", + "\\n * pl" + ], + [ + "`call` is an unsafe replacement for a function call: use ", + "this\\n * function instead.\\n *\\n * If " + ], + [ + "also transferring `value` wei to `target", + "`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value" + ], + [ + "`target` reverts with a revert reason, it is bubbled up by ", + "this\\n * function (like regular Solidity function call" + ], + [ + "transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * ", + "https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://" + ], + [ + "`.\\n * - the called Solidity function must be `payable", + "`" + ], + [ + ",\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode", + "`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], bu", + "t\\n * " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but ", + "also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value" + ], + [ + ".\\n * - calling `target` with `data` must not revert", + ".\\n *\\n * _Available since v3.1._\\n */\\n function functionCall" + ], + [ + "s).\\n *\\n * Returns the raw returned data. To convert to the expected return value", + ",\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract" + ], + [ + "`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If ", + "`target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function call" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value", + "`.\\n * - the called Solidity function must be `payable`" + ], + [ + "s).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract", + ".\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall" + ], + [ + "`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function call", + "s).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall" + ], + [ + "(", + "uint16 _" + ], + [ + ")", + ". " + ], + [ + "\\r", + "\\n " + ], + [ + " ", + " " + ], + [ + "decim", + "al representation.\\n */\\n function " + ], + [ + "0 ", + "000 " + ], + [ + " of two unsigned integers, ", + "with an " + ], + [ + "\\n * - ", + "a contract in construction" + ], + [ + "\\n * - ", + "an externally-owned account" + ], + [ + "sour", + "ce " + ], + [ + "_transferOwnership(", + "address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n " + ], + [ + "EnumerableSet", + "." + ], + [ + ") public view virtual override returns (uint256) {\\n return ", + "_balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `" + ], + [ + "a contract.\\n *\\n * ", + "[IMPORTANT]\\n * ====\\n * " + ], + [ + "a contract.\\n *\\n * ", + "Among others, `isContract` will return false for the following\\n * " + ], + [ + ":\\n *", + "\\n * - an externally-owned account" + ], + [ + ".safeTransfer", + "From" + ], + [ + "\\n * - an address where a contract ", + "will be created" + ], + [ + "\\n * - an address where a contract ", + "lived, but was destroy" + ], + [ + "`account` is ", + "a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * " + ], + [ + "msb", + "(a" + ], + [ + "2**(", + "k" + ], + [ + "mulmod", + "(x, y, " + ], + [ + "enfor", + "c" + ], + [ + "====\\n */\\n function ", + "isContract(address account) internal view returns (bool) {\\n // " + ], + [ + "a different ", + "value " + ], + [ + "select ", + "a different value " + ], + [ + "types of addresses", + ":\\n *\\n * - an externally-owned account" + ], + [ + "uint256 accountBalance = ", + "_balances[account" + ], + [ + "Tow", + "ard " + ], + [ + "It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not ", + "a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * " + ], + [ + "decimal representation.\\n */\\n function ", + "toString" + ], + [ + " of two unsigned integers, with an ", + "overflow " + ], + [ + "\\n * - a contract in construction", + "\\n * - an address where a contract will be created" + ], + [ + "_transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n ", + "_transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n " + ], + [ + "`account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * ", + "It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * " + ], + [ + "types of addresses:\\n *\\n * - an externally-owned account", + "\\n * - a contract in construction\\n * - an address where a contract will be created" + ], + [ + "`account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * ", + "types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created" + ], + [ + "`account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created", + "\\n * - an address where a contract lived, but was destroy" + ], + [ + "!", + "\"" + ], + [ + "5", + "22" + ], + [ + "b", + "ig" + ], + [ + "or", + "dered " + ], + [ + "address", + ") private " + ], + [ + "value", + "Index" + ], + [ + ") {\\n ", + "bytes32 " + ], + [ + "if ", + "not " + ], + [ + "clu", + "de " + ], + [ + "Set", + "s " + ], + [ + "+= ", + "quantity" + ], + [ + "Operator", + "s" + ], + [ + "decimal", + "s = " + ], + [ + "BP", + "S" + ], + [ + "distribu", + "te" + ], + [ + "copy ", + "of the " + ], + [ + "(\\n bytes32 ", + "hash" + ], + [ + "low level ", + "call " + ], + [ + "{\\n /**\\n * @dev Returns true if ", + "`account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroy" + ], + [ + "erc721a", + "/contracts/" + ], + [ + "token collection name", + ".\\n */\\n function name" + ], + [ + "Uniform Resource Identifier (URI) for `tokenId` token", + ".\\n */\\n function tokenURI" + ], + [ + "security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount", + ") internal {\\n require(" + ], + [ + "*", + "." + ], + [ + "U", + "ti" + ], + [ + "b", + "o" + ], + [ + "ed ", + "by" + ], + [ + "\\\"", + "H" + ], + [ + "by ", + "bubbl" + ], + [ + "if (", + "a " + ], + [ + "bytes32 ", + "indexed " + ], + [ + "`from", + "`'s " + ], + [ + "au", + "se" + ], + [ + "18", + "4" + ], + [ + "}\\n ", + "return " + ], + [ + ") internal view virtual ", + "{\\n require(" + ], + [ + ".\\n ", + "if (" + ], + [ + "() external ", + "payable " + ], + [ + "_check", + "ContractOnERC721Received" + ], + [ + "_C", + "HAIN" + ], + [ + "_D", + "OMAIN_SEPARATOR" + ], + [ + "spend", + "Allowance(" + ], + [ + "collateral", + "_" + ], + [ + "with `", + "errorMessage` as a fallback revert reason when `target` reverts" + ], + [ + ",\\n uint amount", + "Token" + ], + [ + ". ", + "If " + ], + [ + "call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes", + "-}[`functionCall`], but " + ], + [ + "TokenOwnership ", + "memory " + ], + [ + "accountBalance ", + "- amount" + ], + [ + "0, errorMessage", + ");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`" + ], + [ + "errorMessage` as a fallback revert reason when `target` reverts", + ".\\n *\\n * _Available since v3.1._\\n */\\n function functionCall" + ], + [ + "with\\n * `", + "errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall" + ], + [ + "was successful", + ", and " + ], + [ + "Privat", + "e " + ], + [ + "Replacement for ", + "Solidity's `" + ], + [ + "applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ", + "ERC20 is Context, IERC20" + ], + [ + "AllTokens", + "Enumeration" + ], + [ + "Tool", + " to " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * ", + "with `errorMessage` as a fallback revert reason when `target` reverts" + ], + [ + "call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but ", + "with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall" + ], + [ + "F", + "AC" + ], + [ + "es", + "ting" + ], + [ + "y ", + "= " + ], + [ + ");", + "\\r\\n function " + ], + [ + "address ", + "operator" + ], + [ + "for ", + "all " + ], + [ + "IERC20", + "Metadata is " + ], + [ + "(from, ", + "address(0), tokenId" + ], + [ + "uint256) {\\n ", + "require(" + ], + [ + ";\\n }\\n\\n /**\\n * @dev See {IERC20-", + "totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (" + ], + [ + "swapExactTokensFor", + "TokensSupportingFeeOnTransferTokens" + ], + [ + "return (", + "true, " + ], + [ + "half ", + "order" + ], + [ + "override returns (bool", + ") {\\n return _" + ], + [ + "address(this).balance ", + ">= value" + ], + [ + "_balances[account] = ", + "accountBalance - amount" + ], + [ + "Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n ", + "_transferOwnership(_msgSender()" + ], + [ + "}(\\\"\\\");\\n require(success", + ", \\\"Address: unable to send value, recipient may have reverted" + ], + [ + "warrant", + "y " + ], + [ + ", \\\"Address: insufficient balance", + "\\\");\\n\\n " + ], + [ + "Decre", + "ase" + ], + [ + ";", + "\\n }\\n" + ], + [ + "re", + "ly " + ], + [ + "on", + "us" + ], + [ + "Token", + "Royalty" + ], + [ + ") external ", + "override " + ], + [ + "value ", + "/= 10" + ], + [ + "can ", + "only " + ], + [ + ".\\n */\\n function _", + "check" + ], + [ + "{\\n require(", + "msg.sender == " + ], + [ + "exp", + "i" + ], + [ + ");\\n ", + " " + ], + [ + ";\\n }\\n ", + "require(" + ], + [ + ") / ", + "2" + ], + [ + "io", + "d " + ], + [ + "packedOwnership", + "Of(tokenId" + ], + [ + " ", + " " + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - The ", + "contract " + ], + [ + "_IN", + "T256" + ], + [ + "\\\");\\n }\\n\\n /**\\n * @dev ", + "Performs a Solidity function call using a low level `call`. A\\n * pl" + ], + [ + "to != address(0), \\\"", + "ERC20: " + ], + [ + ") internal returns (bytes memory) {\\n return functionCallWithValue(target, data, ", + "value, \\\"Address: low-level call with value failed\\\"" + ], + [ + "(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n ", + "require(b" + ], + [ + "}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted", + "\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * pl" + ], + [ + "/", + "solidity" + ], + [ + "9", + "7" + ], + [ + "B", + "o" + ], + [ + "_", + "min" + ], + [ + "d", + "rn" + ], + [ + ", ", + "Errors." + ], + [ + "pu", + "ll" + ], + [ + "(address ", + "=\\u003e " + ], + [ + ". ", + "For " + ], + [ + "at ", + "most " + ], + [ + "Address", + "es" + ], + [ + "on ", + "extcodesize" + ], + [ + "0x", + "5" + ], + [ + "IN", + "S" + ], + [ + "result ", + "< " + ], + [ + ".length", + "; i++) {\\n " + ], + [ + "MIN", + "IMUM" + ], + [ + "oc", + "i" + ], + [ + "sol", + "mate" + ], + [ + "Info", + "." + ], + [ + "them", + " to `to" + ], + [ + "subscri", + "be" + ], + [ + "signer", + " = " + ], + [ + "has", + "Role" + ], + [ + "Metadata ", + "{\\n " + ], + [ + "reentr", + "ant " + ], + [ + "Rel", + "e" + ], + [ + "decimals ", + "places " + ], + [ + "free ", + "softwa" + ], + [ + "exempt", + "from" + ], + [ + "upper ", + "bits " + ], + [ + "using the ", + "provided " + ], + [ + "_index", + "es" + ], + [ + "received ", + "a " + ], + [ + ") internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount", + ");\\n }\\n\\n /**\\n * @dev " + ], + [ + "uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account", + ") public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `" + ], + [ + "constructor execution", + ".\\n" + ], + [ + "This method relies ", + "on extcodesize" + ], + [ + ") internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\"", + ");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts" + ], + [ + "G", + "rowth" + ], + [ + "M", + "Y" + ], + [ + "m", + "ust" + ], + [ + "ee", + ": " + ], + [ + "new", + "Address" + ], + [ + "(\\n address ", + "sender,\\n address recipient" + ], + [ + "abi.encode", + "Packed(" + ], + [ + "direct", + "ly" + ], + [ + "Cre", + "ated" + ], + [ + "Throws ", + "if the " + ], + [ + "gg", + "le" + ], + [ + "compu", + "ting " + ], + [ + "shl", + "(" + ], + [ + "\\n }\\n ", + "}\\n }\\n " + ], + [ + "flash", + " " + ], + [ + "String ", + "operation" + ], + [ + "_CHAIN", + "_ID" + ], + [ + "IERC20Metadata is ", + "IERC20" + ], + [ + "E", + "a" + ], + [ + "_", + "move" + ], + [ + ", ", + "address[] calldata path" + ], + [ + "uint256 ", + "_" + ], + [ + "le", + "ft" + ], + [ + "lo", + "ok" + ], + [ + "\\n * ", + "@notice " + ], + [ + "value ", + "? 1 : 0" + ], + [ + "transfer ", + "amount exceeds the " + ], + [ + "iv", + "en" + ], + [ + "sto", + "re " + ], + [ + "Tx", + "n" + ], + [ + "should ", + "only be " + ], + [ + "fin", + "al " + ], + [ + "amounts", + "In" + ], + [ + "withdraw", + "n" + ], + [ + "s `", + "quantity` " + ], + [ + "divid", + "end" + ], + [ + "encod", + "ed " + ], + [ + ", as ", + "defined in " + ], + [ + "\\\"0", + "123456789abcdef" + ], + [ + "_un", + "chain" + ], + [ + "_init", + "_unchain" + ], + [ + "v0.5.", + "11/" + ], + [ + "subscriptionOrRegistrant", + "ToCopy" + ], + [ + "http://", + "www." + ], + [ + "address(this).balance >= value", + ", \\\"Address: insufficient balance for call" + ], + [ + "decimals places ", + "of the token" + ], + [ + " ", + "address " + ], + [ + ".", + "consensys.net/" + ], + [ + "2", + "d" + ], + [ + "V", + "i" + ], + [ + "_", + "spendAllowance" + ], + [ + "f", + "8" + ], + [ + ", ", + "following the selected rounding direction" + ], + [ + "ed", + "." + ], + [ + "ro", + "z" + ], + [ + "ing", + "Contract" + ], + [ + "\\n ", + "assembly {\\n " + ], + [ + "a ", + "g" + ], + [ + "` ", + "or " + ], + [ + "get", + "RoleMember" + ], + [ + "(\\n address ", + "operator" + ], + [ + ") private ", + "{\\n // " + ], + [ + "Burn", + "ed " + ], + [ + ");\\n require(", + "\\n " + ], + [ + "unchecked {", + "\\r\\n " + ], + [ + "transfers ", + "them to `to" + ], + [ + "map", + "._" + ], + [ + "purpos", + "es" + ], + [ + "Govern", + "or" + ], + [ + "tokens and ", + "transfers them to `to" + ], + [ + "hel", + "per" + ], + [ + "\\n\\n// ", + "This program is " + ], + [ + "33333333", + "33333333" + ], + [ + "Second", + "ary" + ], + [ + "post", + "s/" + ], + [ + ") internal view returns (bytes memory", + ") {\\n return " + ], + [ + "amountTo", + "Burn" + ], + [ + "Statu", + "s" + ], + [ + "decl", + "are " + ], + [ + ". S", + "ince " + ], + [ + "_packedOwnerships[", + "nextTokenId" + ], + [ + "If the next ", + "slot " + ], + [ + "LpBurn", + "Time" + ], + [ + "diligence", + ".consensys.net/" + ], + [ + "Replacement for Solidity's `", + "transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://" + ], + [ + ";\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (", + "uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `" + ], + [ + "diligence.consensys.net/", + "posts/" + ], + [ + "3", + " of the " + ], + [ + "p", + "ty" + ], + [ + "s", + "mar" + ], + [ + " *", + "\\r\\n * " + ], + [ + "ar", + "tist" + ], + [ + "\\\"", + "x" + ], + [ + ");\\n ", + "// " + ], + [ + "Ad", + "min " + ], + [ + "es ", + "= " + ], + [ + "Co", + "st" + ], + [ + "imp", + "lied " + ], + [ + "pro", + "per" + ], + [ + "contract ", + "that " + ], + [ + "the", + "\\n // " + ], + [ + "Em", + "pty" + ], + [ + "to, ", + "amount" + ], + [ + "0, ", + "// " + ], + [ + "any ", + "later " + ], + [ + "}.", + "\\n */\\ninterface " + ], + [ + "ne", + "ed " + ], + [ + ">> ", + "128" + ], + [ + "burned", + "` to `" + ], + [ + "(owner, ", + "address(0), tokenId" + ], + [ + "(uint256 value", + ", uint256 " + ], + [ + "(from, to, tokenId", + ", _data" + ], + [ + "BITMASK", + "_NEXT_INITIALIZED" + ], + [ + "Do", + "main" + ], + [ + "uint8 v", + ", bytes32 r, bytes32 " + ], + [ + "` to the ", + "timestamp of " + ], + [ + " + 1", + "; i" + ], + [ + "startTimestamp", + "` to the timestamp of " + ], + [ + "nextInitialized", + "` to `" + ], + [ + "Protocol", + "Fee" + ], + [ + "overrid", + "den" + ], + [ + "secon", + "ds" + ], + [ + ") internal returns (bytes memory) {\\n require(", + "address(this).balance >= value, \\\"Address: insufficient balance for call" + ], + [ + "https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified", + "[EIP section" + ], + [ + ") {\\n if (success", + ") {\\n return returndata;\\n } else {" + ], + [ + "value >>= ", + "4" + ], + [ + "WARRANT", + "Y" + ], + [ + "Software ", + "Foundation" + ], + [ + "strictly ", + "less than " + ], + [ + "from != address(0), \\\"", + "ERC20: " + ], + [ + "address(this).balance >= amount", + ", \\\"Address: insufficient balance\\\");\\n\\n " + ], + [ + "0 000 ", + "gas.\\n */\\n function supportsInterface(bytes4 interfaceId" + ], + [ + "security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(", + "address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n " + ], + [ + "using the provided ", + "one" + ], + [ + "s `quantity` ", + "tokens and transfers them to `to" + ], + [ + "uint8 v, bytes32 r, bytes32 ", + "s" + ], + [ + " ", + "B" + ], + [ + ")", + ") {\\n " + ], + [ + "A", + "ver" + ], + [ + "G", + "ated" + ], + [ + "_", + "percent" + ], + [ + "p", + "s " + ], + [ + "t", + "ed" + ], + [ + "tr", + "y " + ], + [ + "em", + "ergen" + ], + [ + "get", + "Pair" + ], + [ + "Emits ", + "a {Transfer" + ], + [ + "fee", + "Denominator" + ], + [ + "withdraw", + "able" + ], + [ + "greater than ", + "0" + ], + [ + "(a", + ", b" + ], + [ + "Fun", + "ction" + ], + [ + ", which ", + "can then " + ], + [ + "oft", + "en " + ], + [ + "accountBalance ", + ">= amount, \\\"ERC20: burn " + ], + [ + "owner of the ", + "given token ID" + ], + [ + "isExcludedFrom", + "Fees" + ], + [ + "1] = ", + "\\\"x" + ], + [ + "value == 0", + ", \\\"" + ], + [ + "t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * ", + "We have followed general " + ], + [ + "2", + " * length" + ], + [ + "[", + "value " + ], + [ + "a", + "ren" + ], + [ + "f", + "ill" + ], + [ + "u", + ".org/" + ], + [ + "}", + "\\n */\\n function " + ], + [ + "ri", + "d" + ], + [ + "--", + "i" + ], + [ + "gn", + "u.org/" + ], + [ + "] ", + "`" + ], + [ + "10", + "4" + ], + [ + "ed by ", + "other" + ], + [ + "been ", + "already " + ], + [ + "buffer", + "[0] = " + ], + [ + "MAX", + "_SUPPLY" + ], + [ + "toHexString", + "(value, " + ], + [ + "revoke", + "Role(bytes32 role, address account" + ], + [ + "for (uint256 i", + " = 2" + ], + [ + "[0", + "-" + ], + [ + "LO", + "G" + ], + [ + "functionStaticCall", + "(target, data, \\\"Address: low-level " + ], + [ + "Pausable", + ": " + ], + [ + "array ", + "of " + ], + [ + "set._in", + "ner" + ], + [ + "Com", + "m" + ], + [ + "buffer[", + "i" + ], + [ + "buffer[", + "1] = \\\"x" + ], + [ + "AG", + "E" + ], + [ + " * length", + " + 1; i" + ], + [ + "version ", + "3 of the " + ], + [ + "balanceOf(address(this", + ")" + ], + [ + "bytes memory buffer = new bytes(", + "2 * length" + ], + [ + "uint8) {\\n return ", + "18" + ], + [ + "1; ", + "--i" + ], + [ + "licens", + "es/" + ], + [ + "incip", + "al" + ], + [ + "under the ", + "term" + ], + [ + "Free ", + "Software Foundation" + ], + [ + ", as defined in ", + "the\\n * " + ], + [ + "value == 0, \\\"", + "Strings: hex length insufficient" + ], + [ + "buffer[0] = ", + "\\\"0" + ], + [ + "for (uint256 i = 2", + " * length + 1; i" + ], + [ + "functionStaticCall(target, data, \\\"Address: low-level ", + "static " + ], + [ + "bytes memory buffer = new bytes(2 * length", + " + " + ], + [ + "]", + "{" + ], + [ + "h", + "istor" + ], + [ + "m", + "ade " + ], + [ + " ", + "}\\r\\n" + ], + [ + "\\\"", + "]" + ], + [ + "val", + "u" + ], + [ + "is ", + "18" + ], + [ + "address ", + "representing the " + ], + [ + ") {", + " " + ], + [ + ". ", + "Note: " + ], + [ + "index", + " of the " + ], + [ + "at ", + "your " + ], + [ + "with", + "in " + ], + [ + "The ", + "default " + ], + [ + "the", + "\\n// " + ], + [ + "al ", + "represent" + ], + [ + "ass", + "oci" + ], + [ + "allow", + "s for " + ], + [ + "uint amount", + "Token" + ], + [ + "remain", + "ing" + ], + [ + "bytes memory", + ") {\\n if (success) {\\n return returndata;\\n } else {" + ], + [ + "string,", + "bool," + ], + [ + "slot", + "s " + ], + [ + "uint,", + "uint," + ], + [ + "toHexString", + "(uint256 value, uint256 " + ], + [ + "ven", + "ance" + ], + [ + "Valid", + "ation" + ], + [ + "9a", + "-f" + ], + [ + "explicit", + "Ownership" + ], + [ + "obta", + "in" + ], + [ + "to learn more about how these ids are created.\\n *\\n * This function call must use less than 3", + "0 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId" + ], + [ + "-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data", + ") internal view returns (bytes memory) {\\n return " + ], + [ + "ation with ", + "fixed length" + ], + [ + "====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // ", + "This method relies on extcodesize" + ], + [ + "String operation", + "s.\\n */\\nlibrary " + ], + [ + "[0-", + "9a-f" + ], + [ + "al represent", + "ation with fixed length" + ], + [ + "toHexString(uint256 value, uint256 ", + "length" + ], + [ + "[0-9a-f", + "]{" + ], + [ + " ", + "contract" + ], + [ + "*", + "/\\n function " + ], + [ + "+", + "1" + ], + [ + "7", + "1" + ], + [ + "E", + ". " + ], + [ + "L", + "e" + ], + [ + "f", + "xs" + ], + [ + "en", + "sion " + ], + [ + "to", + "DeleteIndex" + ], + [ + "uint", + ");\\n function " + ], + [ + ", ", + "true" + ], + [ + ", ", + "_msgSender(), " + ], + [ + " = ", + "(1 << " + ], + [ + "Ma", + "p " + ], + [ + ";\\n }\\n\\n /**\\n * @dev ", + "Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://" + ], + [ + "emp", + "ty" + ], + [ + " > ", + "0, errorMessage" + ], + [ + "Set ", + "the " + ], + [ + "For ", + "an " + ], + [ + "\\n // - `", + "burned` to `" + ], + [ + "\\n // - `", + "startTimestamp` to the timestamp of " + ], + [ + "[EIP", + "].\\n *\\n * " + ], + [ + "s of the ", + "GNU General Public License " + ], + [ + "GNU General Public ", + "License" + ], + [ + "VER", + "SION" + ], + [ + ") internal returns (bytes memory) {\\n return functionCallWithValue(target, data, ", + "0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`" + ], + [ + "Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * ", + "https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section" + ], + [ + "1;\\n }\\n ", + "}\\n return " + ], + [ + "WARRANTY", + "; " + ], + [ + "gnu.org/", + "licenses/" + ], + [ + "at your ", + "option" + ], + [ + "Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section", + "]\\n * " + ], + [ + "'", + "s" + ], + [ + "c", + " / " + ], + [ + "con", + "firm" + ], + [ + "require(", + "_" + ], + [ + "0.", + "\\n " + ], + [ + "totalSupply", + "()" + ], + [ + "`from", + "`." + ], + [ + "_transfer", + "(from, to, amount" + ], + [ + "grant", + "Role(bytes32 role, address account" + ], + [ + " > ", + "1; --i" + ], + [ + "s `amount` ", + "of " + ], + [ + "tic ", + "operation" + ], + [ + "after ", + "the " + ], + [ + "value of ", + "{decimals} " + ], + [ + "sec", + "ure" + ], + [ + "override returns (bool", + ") {" + ], + [ + "ERC165 ", + "standard" + ], + [ + "Interface of the ", + "ERC165 standard" + ], + [ + "& 0x", + "f" + ], + [ + ");\\n\\n ", + "function " + ], + [ + "ital", + "Media" + ], + [ + "for more ", + "details." + ], + [ + "_transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n ", + "address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\"" + ], + [ + "[value ", + "& 0xf" + ], + [ + "for (uint256 i = 2 * length + 1; i", + " > 1; --i" + ], + [ + "is 18", + ". To " + ], + [ + "Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * ", + "to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId" + ], + [ + "value of {decimals} ", + "is 18. To " + ], + [ + "(", + "0" + ], + [ + "(", + "at your option" + ], + [ + ") ", + "any later " + ], + [ + "the ", + "implied " + ], + [ + "the ", + "Free Software Foundation" + ], + [ + "` ", + "in " + ], + [ + ") {\\n ", + "_check" + ], + [ + "it ", + "under the term" + ], + [ + "as ", + "publish" + ], + [ + "this ", + "program" + ], + [ + "have ", + "received a " + ], + [ + "lock", + " " + ], + [ + "in the ", + "hop" + ], + [ + "+= ", + "amount;\\n " + ], + [ + "quantity", + "` must be " + ], + [ + "but ", + "WITHOUT " + ], + [ + "e that ", + "it will be " + ], + [ + "Mo", + "ve the " + ], + [ + "Implement", + "ers can " + ], + [ + "not", + ", see " + ], + [ + "without ", + "even " + ], + [ + "contain", + "s" + ], + [ + " or ", + "FITNESS FOR A PARTICULAR PURPOS" + ], + [ + "inher", + "it " + ], + [ + "share", + "s " + ], + [ + "Fl", + "ash" + ], + [ + "support ", + "of contract " + ], + [ + "queri", + "ed by other" + ], + [ + "e it ", + "and/or " + ], + [ + ", either ", + "version 3 of the " + ], + [ + "nft", + "Contract" + ], + [ + "GNU General Public License ", + "for more details." + ], + [ + "along with ", + "this program" + ], + [ + "totalHash", + "es" + ], + [ + "you can ", + "redistribut" + ], + [ + "-name-mixed", + "case" + ], + [ + "ANY ", + "WARRANTY; " + ], + [ + "mag", + "ic " + ], + [ + "re: ", + "you can redistribut" + ], + [ + "distributed ", + "in the hop" + ], + [ + "You should ", + "have received a " + ], + [ + "License, ", + "or" + ], + [ + "MERCHANTABILITY", + " or FITNESS FOR A PARTICULAR PURPOS" + ], + [ + "2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/", + "v0.5.11/" + ], + [ + "coold", + "own" + ], + [ + "copy of the ", + "GNU General Public License" + ], + [ + "{\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroy", + "ed\\n * " + ], + [ + ". If ", + "not, see " + ], + [ + "Private ", + "function to " + ], + [ + "warranty ", + "of" + ], + [ + "free softwa", + "re: you can redistribut" + ], + [ + "declare ", + "support of contract " + ], + [ + "aren", + "'t " + ], + [ + "functionStaticCall(target, data, \\\"Address: low-level static ", + "call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string" + ], + [ + "-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return ", + "functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string" + ], + [ + "E. ", + "See " + ], + [ + "s of the GNU General Public License ", + "as publish" + ], + [ + "(at your option", + ") any later " + ], + [ + "the implied ", + "warranty of" + ], + [ + "the Free Software Foundation", + ", either version 3 of the " + ], + [ + "it under the term", + "s of the GNU General Public License as publish" + ], + [ + "but WITHOUT ", + "ANY WARRANTY; " + ], + [ + "e that it will be ", + "useful" + ], + [ + "Implementers can ", + "declare support of contract " + ], + [ + "without even ", + "the implied warranty of" + ], + [ + "e it and/or ", + "modify" + ], + [ + "along with this program", + ". If not, see " + ], + [ + "distributed in the hop", + "e that it will be useful" + ], + [ + "You should have received a ", + "copy of the GNU General Public License" + ], + [ + "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOS", + "E. See " + ], + [ + "free software: you can redistribut", + "e it and/or modify" + ], + [ + "(at your option) any later ", + "version." + ], + [ + "the Free Software Foundation, either version 3 of the ", + "License, or" + ], + [ + "it under the terms of the GNU General Public License as publish", + "ed by" + ], + [ + "but WITHOUT ANY WARRANTY; ", + "without even the implied warranty of" + ], + [ + "Implementers can declare support of contract ", + "interfaces" + ], + [ + "`", + "balance" + ], + [ + "c", + "p" + ], + [ + "m", + "essage" + ], + [ + "re", + "ed" + ], + [ + "In", + "correct" + ], + [ + "Amount", + "s" + ], + [ + "{\\n ", + "return " + ], + [ + ") external ", + "only" + ], + [ + "balance", + "\"" + ], + [ + "ce", + "\\n // " + ], + [ + "operator", + ", bool approved" + ], + [ + "Data", + "." + ], + [ + ".\\n */\\n function _", + "set" + ], + [ + "constructor", + " (" + ], + [ + "}.\\n */\\n function ", + "isApprovedForAll(address owner, address operator" + ], + [ + "Updat", + "es " + ], + [ + "Wh", + "en" + ], + [ + ";\\n }\\n\\n ", + "/// @notice " + ], + [ + "sum", + " of all " + ], + [ + "functions ", + "from the " + ], + [ + "required ", + "to " + ], + [ + "to be ", + "transferred" + ], + [ + "Cast", + "ed " + ], + [ + "author", + "ized" + ], + [ + "nextInitialized", + "` " + ], + [ + ",\\n ", + "[" + ], + [ + "cas", + "e the " + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8", + ".0) (utils/" + ], + [ + "5` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the ", + "value {ERC20} uses, unless " + ], + [ + "roz", + "en" + ], + [ + "diligence.consensys.net/posts/", + "2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/" + ], + [ + "queried by other", + "s (" + ], + [ + "Implementers can declare support of contract interfaces", + ", which can then " + ], + [ + "functions from the ", + "ERC20 standard" + ], + [ + "v", + "ar" + ], + [ + ", ", + "created " + ], + [ + "token", + "Address" + ], + [ + "uint256 ", + "result" + ], + [ + "\\n function ", + "get" + ], + [ + "no", + "min" + ], + [ + "st", + "at" + ], + [ + "pro", + "por" + ], + [ + "\\r\\n", + "//" + ], + [ + "ha", + "pp" + ], + [ + ") {\\n ", + "buffer[i" + ], + [ + "_approve", + "(address(0), " + ], + [ + "constructor", + "() " + ], + [ + "may ", + "change " + ], + [ + "msg.", + "value " + ], + [ + "packed ", + "= _" + ], + [ + "Par", + "tition" + ], + [ + "\\\");\\n return ", + "string(buffer" + ], + [ + "register", + "And" + ], + [ + "see {", + "ERC165" + ], + [ + "proxy", + "/" + ], + [ + "\\\", \\\"", + "Q" + ], + [ + "All ", + "two " + ], + [ + "\\n\\npragma solidity ^0.8.", + "4" + ], + [ + "\\\";\\n ", + "buffer[1] = \\\"x" + ], + [ + "{ERC165", + "Checker" + ], + [ + "2);\\n ", + "buffer[0] = \\\"0" + ], + [ + "implementation, ", + "see {ERC165" + ], + [ + "Collection of functions related to the address type\\n */\\nlibrary ", + "Address " + ], + [ + "bytes32 indexed ", + "role" + ], + [ + ";\\n }\\n require(", + "value == 0, \\\"Strings: hex length insufficient" + ], + [ + "bytes memory buffer = new bytes(2 * length + ", + "2);\\n buffer[0] = \\\"0" + ], + [ + "For an ", + "implementation, see {ERC165" + ], + [ + "Interface of the ERC165 standard", + ", as defined in the\\n * " + ], + [ + "queried by others (", + "{ERC165Checker" + ], + [ + "\\\";\\n buffer[1] = \\\"x", + "\\\";\\n " + ], + [ + ";\\n }\\n require(value == 0, \\\"Strings: hex length insufficient", + "\\\");\\n return string(buffer" + ], + [ + "bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0", + "\\\";\\n buffer[1] = \\\"x\\\";\\n " + ], + [ + ">", + "." + ], + [ + "C", + "or" + ], + [ + "e", + "ff" + ], + [ + ", ", + "this " + ], + [ + "bl", + "og" + ], + [ + " = ", + "\\\"0123456789abcdef" + ], + [ + ".\\n */\\n function ", + "toHexString(uint256 value, uint256 length" + ], + [ + "po", + "d" + ], + [ + "\\n// ", + "along with this program. If not, see " + ], + [ + "\\n// ", + "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See " + ], + [ + "\\n// ", + "(at your option) any later version." + ], + [ + "\\n// ", + "the Free Software Foundation, either version 3 of the License, or" + ], + [ + "\\n// ", + "it under the terms of the GNU General Public License as published by" + ], + [ + "String", + "s." + ], + [ + "interface ", + "I" + ], + [ + " > ", + "0) {\\n " + ], + [ + "uint amount", + "A" + ], + [ + "ENT", + "ERED" + ], + [ + ";\\n\\n /**\\n * @dev ", + "Converts a `uint256` to its ASCII `string` " + ], + [ + "receiver", + " " + ], + [ + " = _", + "baseURI" + ], + [ + "forma", + "t " + ], + [ + "Liqui", + "dity " + ], + [ + "_ownership", + "s[" + ], + [ + "BBBBBBBB", + "BBBBBBBB" + ], + [ + "\\n\\n// ", + "You should have received a copy of the GNU General Public License" + ], + [ + "revok", + "ed " + ], + [ + "aver", + "age" + ], + [ + "al representation.\\n */\\n function toHexString", + "(uint256 value) internal pure returns (string memory) {\\n " + ], + [ + "wik", + "i/" + ], + [ + "bug", + "s, " + ], + [ + ",\\n// ", + "but WITHOUT ANY WARRANTY; without even the implied warranty of" + ], + [ + "bytes16 ", + "private constant _" + ], + [ + ") internal pure returns (string memory) {\\n ", + "bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n " + ], + [ + "\\n\\n// This program is ", + "distributed in the hope that it will be useful" + ], + [ + "the\\n// ", + "GNU General Public License for more details." + ], + [ + "al representation with fixed length", + ".\\n */\\n function toHexString(uint256 value, uint256 length" + ], + [ + "free software: you can redistribute it and/or modify", + "\\n// it under the terms of the GNU General Public License as published by" + ], + [ + "Implementers can declare support of contract interfaces, which can then ", + "be\\n * " + ], + [ + "\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See ", + "the\\n// GNU General Public License for more details." + ], + [ + "\\n// (at your option) any later version.", + "\\n\\n// This program is distributed in the hope that it will be useful" + ], + [ + "\\n// the Free Software Foundation, either version 3 of the License, or", + "\\n// (at your option) any later version.\\n\\n// This program is distributed in the hope that it will be useful" + ], + [ + ";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` ", + "decimal representation.\\n */\\n function toString" + ], + [ + "\\n\\n// You should have received a copy of the GNU General Public License", + "\\n// along with this program. If not, see " + ], + [ + ",\\n// but WITHOUT ANY WARRANTY; without even the implied warranty of", + "\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\n// GNU General Public License for more details." + ], + [ + "free software: you can redistribute it and/or modify\\n// it under the terms of the GNU General Public License as published by", + "\\n// the Free Software Foundation, either version 3 of the License, or\\n// (at your option) any later version.\\n\\n// This program is distributed in the hope that it will be useful" + ], + [ + ",\\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\n// GNU General Public License for more details.", + "\\n\\n// You should have received a copy of the GNU General Public License\\n// along with this program. If not, see " + ], + [ + "free software: you can redistribute it and/or modify\\n// it under the terms of the GNU General Public License as published by\\n// the Free Software Foundation, either version 3 of the License, or\\n// (at your option) any later version.\\n\\n// This program is distributed in the hope that it will be useful", + ",\\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\n// GNU General Public License for more details.\\n\\n// You should have received a copy of the GNU General Public License\\n// along with this program. If not, see " + ], + [ + "_", + "take" + ], + [ + "_", + "excluded" + ], + [ + "all", + " the " + ], + [ + "call", + "able " + ], + [ + "pro", + "ject " + ], + [ + "resul", + "ting " + ], + [ + "string memory ", + "name" + ], + [ + "\\n * @dev ", + "See " + ], + [ + "String", + "s {\\n " + ], + [ + ");\\r\\n", + " " + ], + [ + "collateral", + "Token" + ], + [ + "contract is ", + "paused" + ], + [ + ",\\r\\n ", + "\\\"" + ], + [ + " <= ", + "a" + ], + [ + "https://eips.ethereum.org/EIPS/eip-165", + "[EIP].\\n *\\n * " + ], + [ + "\"lib/", + "openzeppelin-contracts/contracts/" + ], + [ + "added ", + "or " + ], + [ + "When `from` and `to` are both non-zero, ", + "`from`'s " + ], + [ + "JSON", + "-R" + ], + [ + "caller is not owner nor ", + "approved" + ], + [ + "burned by ", + "`from`." + ], + [ + "}).\\n *\\n * ", + "For an implementation, see {ERC165" + ], + [ + "queried by others ({ERC165Checker", + "}).\\n *\\n * For an implementation, see {ERC165" + ], + [ + "al representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length", + ") internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n " + ], + [ + "Implementers can declare support of contract interfaces, which can then be\\n * ", + "queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165" + ], + [ + "Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165", + "}.\\n */\\ninterface " + ], + [ + "L", + "OO" + ], + [ + "X", + "SD" + ], + [ + "s", + ";\\n " + ], + [ + "\\\"", + "\\r\\n " + ], + [ + "\\\"", + " (" + ], + [ + "tokens ", + "to " + ], + [ + "tokens", + "OfOwner" + ], + [ + ";\\n ", + "}\\n " + ], + [ + "\\r\\n * ", + "@param _" + ], + [ + "mis", + "sion" + ], + [ + "Non", + "ce" + ], + [ + "ust", + "ed" + ], + [ + "reverting on\\n * overflow", + ".\\n *\\n * " + ], + [ + "AB", + "I" + ], + [ + ");\\n ", + "}\\n\\n function " + ], + [ + "process", + "Proof" + ], + [ + "_statu", + "s = _" + ], + [ + "];\\n ", + "value >>= 4" + ], + [ + "uint256 c = ", + "a + b" + ], + [ + "optional metadata ", + "functions from the ERC20 standard" + ], + [ + "signific", + "ant " + ], + [ + "(Counter storage counter", + ") internal {\\n " + ], + [ + "\"// SPDX-License-Identifier: GPL-3.0-or-later", + "\\n// " + ], + [ + ";\\n\\n mapping(address => ", + "mapping(address => uint256" + ], + [ + " from int256, reverting on\\n * overflow (when the input is less than smallest ", + "int" + ], + [ + "\\\"]", + ",\\n [" + ], + [ + "[value & 0xf", + "];\\n value >>= 4" + ], + [ + "for (uint256 i = 2 * length + 1; i > 1; --i", + ") {\\n buffer[i" + ], + [ + "Interface of the ERC165 standard, as defined in the\\n * ", + "https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * " + ], + [ + "[value & 0xf];\\n value >>= 4", + ";\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer" + ], + [ + "Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * ", + "Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface " + ], + [ + ".", + "\\n // - `startTimestamp` to the timestamp of " + ], + [ + "<", + "http://www." + ], + [ + "D", + "D" + ], + [ + "d", + "s-" + ], + [ + ", ", + "uint8 v, bytes32 r, bytes32 s" + ], + [ + "se", + "ed " + ], + [ + "address ", + "signer = " + ], + [ + "16", + "8" + ], + [ + "Em", + "it " + ], + [ + "`.", + "\\n " + ], + [ + "revert", + "` " + ], + [ + "Open", + "Se" + ], + [ + "cent", + "i" + ], + [ + "dis", + "abled" + ], + [ + "Wh", + "ether " + ], + [ + "verif", + "ication" + ], + [ + "del", + "ta" + ], + [ + "IUniswapV2Router0", + "1" + ], + [ + "();\\n\\n ", + "_beforeTokenTransfers" + ], + [ + "ing.", + "\\n // - `burned` to `" + ], + [ + "`.\\n // - `", + "nextInitialized` to `" + ], + [ + "Updates:\\n // - `", + "address" + ], + [ + "`tokenId", + "`" + ], + [ + "_ref", + "lect" + ], + [ + "sw", + "it" + ], + [ + "currentAllowance >= ", + "subtractedValue, \\\"ERC20: decreased allowance below zero" + ], + [ + "MY", + "_ROLE" + ], + [ + "gnu.org/licenses/", + ">." + ], + [ + "added or ", + "removed" + ], + [ + "." + ], + [ + "C", + "K" + ], + [ + "G", + "iven" + ], + [ + "i", + "er" + ], + [ + "to", + "g" + ], + [ + "is", + "exemptfrom" + ], + [ + "amount", + "\\r\\n " + ], + [ + "\\r", + "\\n *\\r\\n * " + ], + [ + "Token", + " is " + ], + [ + "Th", + "ere " + ], + [ + "get", + "Reserves" + ], + [ + "_A", + "M" + ], + [ + "hash", + "es[" + ], + [ + "\\n */\\n function ", + "set" + ], + [ + "0 ", + "&& " + ], + [ + "result", + ";\\n }\\n\\n /**\\n * @dev " + ], + [ + ");\\n }\\n\\n function ", + "set" + ], + [ + "ApprovalForAll", + "(address indexed owner, address indexed " + ], + [ + "this function ", + "uses " + ], + [ + "access/", + "AccessControl" + ], + [ + "bytes(", + "baseURI" + ], + [ + "(address to, uint256 ", + "quantity" + ], + [ + "uses ", + "an " + ], + [ + ");\\n }\\n ", + "}\\n }\\n\\n /**\\n * @dev " + ], + [ + "some", + "how " + ], + [ + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n return ", + "a " + ], + [ + "chil", + "d" + ], + [ + "opcode (which leaves remaining gas untouched) while ", + "Solidity" + ], + [ + ",\\r\\n address to", + ",\\r\\n uint256 " + ], + [ + "It", + "em" + ], + [ + "/` operator", + ". Note: " + ], + [ + "amount\\n ) external ", + "returns (bool" + ], + [ + "quantity` must be ", + "greater than 0" + ], + [ + "free software: you can redistribute it and/or modify\\n// it under the terms of the GNU General Public License as published by\\n// the Free Software Foundation, either version 3 of the License, or\\n// (at your option) any later version.\\n\\n// This program is distributed in the hope that it will be useful,\\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\n// GNU General Public License for more details.\\n\\n// You should have received a copy of the GNU General Public License\\n// along with this program. If not, see ", + "." + ], + [ + "al representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n ", + "for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i" + ], + [ + "revert` ", + "opcode (which leaves remaining gas untouched) while Solidity" + ], + [ + "ApprovalForAll(address indexed owner, address indexed ", + "operator, bool approved" + ], + [ + "/` operator. Note: ", + "this function uses " + ], + [ + "M", + "igr" + ], + [ + "T", + "ri" + ], + [ + "n", + "ip" + ], + [ + "s ", + "in the " + ], + [ + "im", + "il" + ], + [ + "su", + "re the " + ], + [ + "ip", + " " + ], + [ + "in ", + "case the " + ], + [ + " to ", + "`" + ], + [ + " of ", + "its " + ], + [ + ";\\n", + "\\n " + ], + [ + "num", + "Tokens" + ], + [ + "Rol", + "es" + ], + [ + "new ", + "uint256" + ], + [ + "ap", + "s" + ], + [ + "ap", + "ter" + ], + [ + "\"@openzeppelin/contracts/", + "token/ERC20/IERC20.sol\"" + ], + [ + "dis", + "able " + ], + [ + "19", + "1" + ], + [ + " from ", + "the " + ], + [ + "-= ", + "1;\\n " + ], + [ + " of two unsigned integers, ", + "reverting on\\n * overflow.\\n *\\n * " + ], + [ + "Exceed", + "s" + ], + [ + "Down", + "(" + ], + [ + "Ent", + "ries" + ], + [ + "_isApprovedOrOwner", + "(_msgSender(), " + ], + [ + "lower 160", + " bits, " + ], + [ + "mstore8", + "(" + ], + [ + "uint256 accountBalance = _balances[account", + "];\\n require(" + ], + [ + "upper bits ", + "somehow " + ], + [ + "s `amount` of ", + "tokens from " + ], + [ + "aren't ", + "clean" + ], + [ + "in case the ", + "upper bits somehow " + ], + [ + "lower 160 bits, ", + "in case the upper bits somehow " + ], + [ + "lower 160 bits, in case the upper bits somehow ", + "aren't clean" + ], + [ + "M", + "eta" + ], + [ + "S", + "N" + ], + [ + "l", + "if" + ], + [ + "s ", + "of a " + ], + [ + ", ", + "bytes calldata " + ], + [ + "or", + "d " + ], + [ + "ERC", + "777" + ], + [ + "\\n * ", + "{" + ], + [ + "tokenId", + ", _data" + ], + [ + "ai", + "ly" + ], + [ + "with ", + "the\\n * " + ], + [ + ";\\n\\n ", + "function " + ], + [ + "Ch", + "iru" + ], + [ + "(msg.sender", + ", _" + ], + [ + ";\\r\\n ", + "uint256 public " + ], + [ + "access/Ownable", + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev " + ], + [ + "manage ", + "the " + ], + [ + "] = _", + "packOwnershipData" + ], + [ + "token/ERC20/ERC20", + ".sol\"" + ], + [ + "otherwis", + "e " + ], + [ + "_allowances[", + "sender" + ], + [ + "granted `role`, emits a {Role", + "Revoked" + ], + [ + "extra", + "Data = " + ], + [ + "leavesL", + "en " + ], + [ + "dy", + "nam" + ], + [ + " been ", + "granted `role`, emits a {RoleRevoked" + ], + [ + "\\n * - `from` and `to` are never both zero", + ".\\n */\\n function _" + ], + [ + " of two unsigned integers, with an overflow ", + "flag.\\n *\\n * _Available since v3.4._\\n */\\n function try" + ], + [ + "Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId", + ") external view returns (bool);\\n}\\n\"" + ], + [ + "diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/", + "security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n " + ], + [ + "burned by `from`.", + "\\n * - `from` and `to` are never both zero.\\n */\\n function _" + ], + [ + "Chiru", + " L" + ], + [ + "access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev ", + "Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _transferOwnership(_msgSender()" + ], + [ + ".", + "°" + ], + [ + ".", + "toString" + ], + [ + "B", + "ps" + ], + [ + "I", + "OperatorFilterRegistry" + ], + [ + "d", + "en " + ], + [ + "{", + "length" + ], + [ + "°", + "." + ], + [ + "re", + "buil" + ], + [ + "ERC", + "ENT" + ], + [ + "index", + "` must be " + ], + [ + "pro", + "xy " + ], + [ + "\\r\\n", + "\\t\\t" + ], + [ + "par", + "t" + ], + [ + "burn", + "ed = " + ], + [ + "when ", + "more " + ], + [ + "non", + "c" + ], + [ + ") {\\n ", + " " + ], + [ + "AT", + "ER" + ], + [ + "was ", + "not\\n * " + ], + [ + "array", + ", and it " + ], + [ + "eri", + "ting " + ], + [ + "initializ", + "ed" + ], + [ + "Note that ", + "there are no " + ], + [ + "Man", + "ual" + ], + [ + "order", + "ing of " + ], + [ + "Sub", + "scri" + ], + [ + "Move", + "s `amount` of tokens from " + ], + [ + "0;\\n ", + "unchecked {\\n " + ], + [ + ");\\n }\\n ", + "}\\n }\\n}\\n\"" + ], + [ + "pragma solidity 0.8.", + "17" + ], + [ + "position ", + "`index` " + ], + [ + "avoid", + "-" + ], + [ + "s on the ", + "ordering of " + ], + [ + "guarantee", + "s on the ordering of " + ], + [ + "stored at ", + "position `index` " + ], + [ + "OWN", + "ER" + ], + [ + "https://github.com/OpenZeppelin/", + "openzeppelin-contracts/" + ], + [ + "strictly less than ", + "{length" + ], + [ + "may change ", + "when more " + ], + [ + "index` must be ", + "strictly less than {length" + ], + [ + "was not\\n * ", + "already " + ], + [ + "array, and it ", + "may change when more " + ], + [ + "Note that there are no ", + "guarantees on the ordering of " + ], + [ + "1", + "a" + ], + [ + "2", + "16" + ], + [ + "C", + "r" + ], + [ + "P", + "ass" + ], + [ + "i", + "gn" + ], + [ + "is", + "Operator" + ], + [ + "ing ", + "to the " + ], + [ + " = ", + "5" + ], + [ + "operator", + "-f" + ], + [ + "when ", + "a " + ], + [ + "!= ", + "0) {\\n " + ], + [ + "Max", + "Length" + ], + [ + "Str", + "ategy" + ], + [ + ".\\n ", + "unchecked {\\n // " + ], + [ + "slot", + "'s " + ], + [ + "assembly {", + "\\n // " + ], + [ + "initializ", + "er " + ], + [ + "ilter", + "-" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0", + ";\\n\\nimport \\\"./" + ], + [ + "\\\");", + "\\n " + ], + [ + "sa", + "ve " + ], + [ + "free ", + "memory " + ], + [ + ".sol';\\nimport '", + "@openzeppelin/contracts/" + ], + [ + "based ", + "on " + ], + [ + "(address from, address to, uint256 ", + "tokenId" + ], + [ + "decimals places of the token", + ".\\n */\\n function " + ], + [ + "The default ", + "value of {decimals} is 18. To " + ], + [ + "String operations.\\n */\\nlibrary ", + "Strings {\\n " + ], + [ + "JSON-R", + "PC " + ], + [ + "_isApprovedOrOwner(_msgSender(), ", + "tokenId" + ], + [ + "operator-f", + "ilter-" + ], + [ + "\\", + "x" + ], + [ + "n", + "d " + ], + [ + "s", + "on " + ], + [ + "Token", + "Amount" + ], + [ + "\\n * ", + "(" + ], + [ + "32", + ";\\n result += " + ], + [ + "recipient", + "` cannot be the zero address" + ], + [ + "the zero address", + ".\\n */\\n error " + ], + [ + "16", + ";\\n result += " + ], + [ + "operator", + "Data" + ], + [ + "64", + ";\\n result += " + ], + [ + "lea", + "v" + ], + [ + ".\\n ", + "assembly {\\n " + ], + [ + "Tx", + "Limit" + ], + [ + ".\\n *\\n * ", + "_Available since v4.1._" + ], + [ + "try", + "Sub" + ], + [ + "try", + "Mod" + ], + [ + "(value", + ");\\n return result + (rounding == Rounding.Up && " + ], + [ + "(uint256 value", + ") internal pure returns (uint256) {\\n uint256 result = " + ], + [ + "(uint256 value", + ", Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = " + ], + [ + "result += ", + "1;\\n }\\n }\\n return " + ], + [ + "17", + "6" + ], + [ + ");\\n }\\n }\\n\\n /**\\n * @dev ", + "Return the log in base " + ], + [ + "inherit", + "doc" + ], + [ + "\\n\\t *", + "\\n\\t * " + ], + [ + "Sy", + "nc" + ], + [ + "Creator", + ": " + ], + [ + "\\n */\\n ", + "event " + ], + [ + "`nonReentrant` ", + "function " + ], + [ + "name of the token.\\n */\\n function name", + "() external view returns (string memory);\\n\\n /**\\n * @dev Returns the " + ], + [ + "_d", + "18" + ], + [ + "circ", + "um" + ], + [ + ") external view returns (uint256 ", + "balance" + ], + [ + "deprec", + "ated " + ], + [ + "0,\\n ", + "0,\\n " + ], + [ + "result;\\n }\\n\\n /**\\n * @dev ", + "Return the log in base " + ], + [ + "0;\\n unchecked {\\n ", + "if (value " + ], + [ + "(uint256 value) internal pure returns (uint256) {\\n uint256 result = ", + "0;\\n unchecked {\\n if (value " + ], + [ + "result += 1;\\n }\\n }\\n return ", + "result;\\n }\\n\\n /**\\n * @dev Return the log in base " + ], + [ + "(", + "uint8(" + ], + [ + "/", + " " + ], + [ + "]", + ", " + ], + [ + "el", + "oper" + ], + [ + "Owner", + "QueryForNonexistentToken" + ], + [ + "ch", + "e" + ], + [ + "(address ", + "recovered" + ], + [ + "memory ", + "for the " + ], + [ + "name", + ", " + ], + [ + " _", + "nextExtraData" + ], + [ + "URI", + "QueryForNonexistentToken" + ], + [ + "since ", + "it " + ], + [ + "Out", + "(" + ], + [ + "██", + "║" + ], + [ + "dis", + "abl" + ], + [ + "\\n *\\n * ", + "NOTE: This " + ], + [ + " ", + " " + ], + [ + "\\n * @", + "author " + ], + [ + "TokenOwnership", + "` " + ], + [ + "Param", + "s " + ], + [ + "_IN", + "TER" + ], + [ + "` to the ", + "lower 160 bits, in case the upper bits somehow aren't clean" + ], + [ + " {\\n /**\\n * @dev Returns the ", + "name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the " + ], + [ + ", IERC20", + "Metadata {\\n " + ], + [ + "overrid", + "den " + ], + [ + "(uint256 tokenId) external view returns (", + "address owner" + ], + [ + "symbol of the token", + ".\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the " + ], + [ + "Treasury", + "Fee" + ], + [ + "This program is ", + "free software: you can redistribute it and/or modify\\n// it under the terms of the GNU General Public License as published by\\n// the Free Software Foundation, either version 3 of the License, or\\n// (at your option) any later version.\\n\\n// This program is distributed in the hope that it will be useful,\\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\n// GNU General Public License for more details.\\n\\n// You should have received a copy of the GNU General Public License\\n// along with this program. If not, see ." + ], + [ + ") return (false, 0", + ");\\n return (" + ], + [ + "as part ", + "of " + ], + [ + " of two unsigned integers, reverting ", + "with custom message " + ], + [ + "mload(add(signature", + ", 0x" + ], + [ + "concaten", + "ation" + ], + [ + "decimals places of the token.\\n */\\n function ", + "decimals() external view returns (uint8" + ], + [ + "symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the ", + "decimals places of the token.\\n */\\n function decimals() external view returns (uint8" + ], + [ + ") return (false, 0);\\n return (", + "true, " + ], + [ + "(", + "a + b" + ], + [ + "1", + "20" + ], + [ + "C", + "AN" + ], + [ + "I", + "G" + ], + [ + "M", + "ut" + ], + [ + "s", + ".sol\"" + ], + [ + "t", + "re" + ], + [ + "s ", + "< " + ], + [ + "acc", + "es" + ], + [ + "bool", + ")" + ], + [ + " = ", + "\\\"" + ], + [ + "min", + "im" + ], + [ + "pay", + "er" + ], + [ + "address,", + "address" + ], + [ + "level", + "-call" + ], + [ + ") / ", + "_" + ], + [ + "recover", + "}.\\n */\\n function " + ], + [ + "low-", + "level-call" + ], + [ + "(from, to, tokenId", + ", 1" + ], + [ + "\\n * @param ", + "tokenId uint256 ID of the token" + ], + [ + "s `", + "tokenId" + ], + [ + "resp", + "on" + ], + [ + "comput", + "e the " + ], + [ + "glob", + "al " + ], + [ + ".\\n *\\n * See {", + "recover}.\\n */\\n function " + ], + [ + "bene", + "fit " + ], + [ + "✓✓", + "✓✓" + ], + [ + "alloc", + "ating " + ], + [ + "`\\n * ", + "opcode (which leaves remaining gas untouched) while Solidity uses " + ], + [ + ", bool _", + "approved" + ], + [ + "voc", + "ation" + ], + [ + "%` operator. This function uses a `revert", + "`\\n * opcode (which leaves remaining gas untouched) while Solidity uses " + ], + [ + "ERC-721 ", + "Non-Fungible Token Standard" + ], + [ + "helper", + "s/" + ], + [ + "\"// SPDX-License-Identifier: GPL-3.0-or-later\\n// ", + "This program is free software: you can redistribute it and/or modify\\n// it under the terms of the GNU General Public License as published by\\n// the Free Software Foundation, either version 3 of the License, or\\n// (at your option) any later version.\\n\\n// This program is distributed in the hope that it will be useful,\\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\n// GNU General Public License for more details.\\n\\n// You should have received a copy of the GNU General Public License\\n// along with this program. If not, see ." + ], + [ + "Chiru L", + "abs" + ], + [ + " {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the ", + "symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8" + ], + [ + "%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses ", + "an\\n * " + ], + [ + " ", + "\\u003c" + ], + [ + "C", + "TION" + ], + [ + "D", + "ig" + ], + [ + "_", + "enabled" + ], + [ + "a", + "ting" + ], + [ + "s", + "\\n * " + ], + [ + "y", + "et" + ], + [ + "s ", + "use {" + ], + [ + "un", + "necessari" + ], + [ + "ly", + ". For " + ], + [ + "Th", + "is\\n * " + ], + [ + ") {\\n ", + "/// @solidity memory-safe-assembly\\n assembly {\\n " + ], + [ + ") internal ", + "pure " + ], + [ + "0000", + "000" + ], + [ + "ut", + "down" + ], + [ + "Require", + "d " + ], + [ + "Str", + "uc" + ], + [ + "oper", + "ate " + ], + [ + "message ", + "unnecessari" + ], + [ + "Emitted when ", + "`tokenId` token is " + ], + [ + "custom ", + "revert reason" + ], + [ + "Wrapp", + "ers " + ], + [ + "amount);\\n ", + "emit Transfer" + ], + [ + "series", + "Sum" + ], + [ + "CAUTION: ", + "This function is " + ], + [ + "requires ", + "allocating " + ], + [ + "Subtraction ", + "cannot overflow.\\n */\\n function " + ], + [ + "because it ", + "requires allocating " + ], + [ + ";\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://", + "diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n " + ], + [ + "inherit ", + "from " + ], + [ + "Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface ", + "IERC165 {\\n /**\\n * @dev " + ], + [ + "inheritdoc", + " " + ], + [ + "Creator: ", + "Chiru Labs" + ], + [ + "deprecated ", + "because it requires allocating " + ], + [ + "memory for the ", + "error" + ], + [ + "ly. For ", + "custom revert reason" + ], + [ + "message unnecessari", + "ly. For custom revert reason" + ], + [ + "CAUTION: This function is ", + "deprecated because it requires allocating " + ], + [ + "message unnecessarily. For custom revert reason", + "s use {" + ], + [ + "CAUTION: This function is deprecated because it requires allocating ", + "memory for the error" + ], + [ + "F", + "arm" + ], + [ + "V", + "X" + ], + [ + "_", + "revert" + ], + [ + "a", + "9" + ], + [ + "to", + "ggle" + ], + [ + "\\n *", + " " + ], + [ + "a ", + "token " + ], + [ + "a ", + "given " + ], + [ + "Transfer", + "` " + ], + [ + "), ", + "mload(" + ], + [ + "\\r\\n", + "\\t" + ], + [ + "sender", + " " + ], + [ + "will ", + "receive the " + ], + [ + " <", + "<" + ], + [ + "approved", + ", uint256 " + ], + [ + "FFFF", + "FF" + ], + [ + "https://eips.ethereum.org/EIPS/eip-", + "2612" + ], + [ + "FFFFFFFF", + "FFFFFF" + ], + [ + "initializ", + "ed " + ], + [ + "on\\n * ", + "division by zero. The result is rounded towards " + ], + [ + "Strings", + ".sol\"" + ], + [ + "values ", + "inside " + ], + [ + "values are ", + "added or removed" + ], + [ + "Wallet ", + "= " + ], + [ + "Remove", + "s a value " + ], + [ + "ardi", + "z" + ], + [ + "remainder of dividing two unsigned integers. (unsigned integer modulo", + "),\\n * " + ], + [ + "magic ", + "value" + ], + [ + "\\n * @dev See ", + "https://eips.ethereum.org/EIPS/eip-721" + ], + [ + "array, and it may change when more ", + "values are added or removed" + ], + [ + "Note that there are no guarantees on the ordering of ", + "values inside " + ], + [ + "ERC-721 Non-Fungible Token Standard", + ", " + ], + [ + "Subtraction cannot overflow.\\n */\\n function ", + "sub" + ], + [ + "Removes a value ", + "from a " + ], + [ + "'", + "re " + ], + [ + "-", + "of" + ], + [ + "6", + "4." + ], + [ + "{", + "permit" + ], + [ + "an", + "other" + ], + [ + "256", + " bit " + ], + [ + "ex", + "per" + ], + [ + "anc", + "ake" + ], + [ + "to ", + "avoid " + ], + [ + "address ", + "spender" + ], + [ + "a ", + "role" + ], + [ + "of ", + "two numbers" + ], + [ + "20", + "8" + ], + [ + "return ", + "the " + ], + [ + "pa", + "use " + ], + [ + "ting ", + "the " + ], + [ + "` to ", + "manage the " + ], + [ + "ati", + "vel" + ], + [ + "s for ", + "uint256" + ], + [ + "packed ", + "& _BITMASK" + ], + [ + "`) ", + "`operator` to " + ], + [ + "produc", + "es " + ], + [ + "comm", + "on" + ], + [ + "PP", + "PP" + ], + [ + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically ", + "increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n " + ], + [ + "\\n *", + "/\\n function " + ], + [ + "manage all", + " of its " + ], + [ + "`approved", + "` to manage the " + ], + [ + "See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual ", + "override returns (bool) {\\n return interfaceId == type(" + ], + [ + "set._indexes[", + "value" + ], + [ + "IERC20Metadata is IERC20", + " {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8" + ], + [ + "associ", + "ated " + ], + [ + "uint256 accountBalance = _balances[account];\\n require(", + "accountBalance >= amount, \\\"ERC20: burn " + ], + [ + "] = _packOwnershipData", + "(\\n " + ], + [ + "avoid-", + "low-level-call" + ], + [ + "of two numbers", + ".\\n */\\n function " + ], + [ + "`) `operator` to ", + "manage all of its " + ], + [ + "`approved` to manage the ", + "`tokenId` token" + ], + [ + "6", + "3" + ], + [ + "N", + "omin" + ], + [ + "_", + "writeCheckpoint" + ], + [ + "s", + "imp" + ], + [ + "to ", + "its " + ], + [ + "), ", + "and " + ], + [ + "recipient", + ", amount" + ], + [ + "if (", + "_" + ], + [ + "balances", + "[" + ], + [ + "swap", + "AndLiquify" + ], + [ + ";\\n }\\n\\n /**\\n * @dev ", + "Add " + ], + [ + "id", + "s" + ], + [ + "string memory ", + "baseURI" + ], + [ + "emp", + "ty " + ], + [ + "one ", + "signed " + ], + [ + "transferred ", + "from `from` to `to`" + ], + [ + "() public view virtual override returns (", + "uint8) {\\n return 18" + ], + [ + "method ", + "as part of " + ], + [ + "10000", + "0" + ], + [ + "fee ", + "recipient" + ], + [ + "statu", + "s" + ], + [ + "ensu", + "re " + ], + [ + "paramet", + "er " + ], + [ + "(uint256 tokenId) external view returns (", + "address operator" + ], + [ + "FFFFFFFFFFFFFFFF", + "FFFFFFFFFFFFFF" + ], + [ + "_LI", + "QUIDITY" + ], + [ + "Vo", + "ting" + ], + [ + "RecoverError error", + ") = " + ], + [ + "RU", + "CT" + ], + [ + "String operations.\\n */\\nlibrary Strings {\\n ", + "bytes16 private constant _" + ], + [ + "JSON-RPC ", + "method as part of " + ], + [ + "circum", + "vent" + ], + [ + "(address recovered", + ", " + ], + [ + "-of", + "-" + ], + [ + "{permit", + "} " + ], + [ + "JSON-RPC method as part of ", + "EIP-" + ], + [ + "\"", + "TOKEN" + ], + [ + ")", + ");\\n }\\n\\n function " + ], + [ + ".", + "\\n */\\n function " + ], + [ + "8", + "5" + ], + [ + "<", + "< _" + ], + [ + "S", + "tar" + ], + [ + "_", + "delegate" + ], + [ + "p", + "end" + ], + [ + "re", + "nd" + ], + [ + "tr", + "ibu" + ], + [ + "se", + "ed" + ], + [ + "20", + "98" + ], + [ + "by ", + "mak" + ], + [ + "ck", + "pt" + ], + [ + "\\r\\n ", + "// " + ], + [ + ", address ", + "to, " + ], + [ + "Recei", + "ve" + ], + [ + "pre", + "-" + ], + [ + "data ", + "structu" + ], + [ + "uint256) {\\n return ", + "_" + ], + [ + "baseURI", + ", " + ], + [ + "_set", + "Owner" + ], + [ + "\\n ) external ", + "payable" + ], + [ + "where ", + "the " + ], + [ + "Al", + "read" + ], + [ + "\\\"\\n ", + ");\\n\\n " + ], + [ + "Fee ", + "+ " + ], + [ + "_packedOwnership", + "s" + ], + [ + "https://github.com/ethereum", + "/solidity" + ], + [ + "list ", + "of " + ], + [ + "() public view virtual override returns (string memory) {\\n return _name", + ";\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol" + ], + [ + "interes", + "t" + ], + [ + " or", + "\\n * greater than largest int" + ], + [ + "mapping(address => uint256) private _balances", + ";\\n\\n mapping(address => mapping(address => uint256" + ], + [ + "convention", + "al " + ], + [ + "account.\\n */\\n function balanceOf(address owner", + ") external view returns (uint256 balance" + ], + [ + "\\r\\n /**", + "\\r\\n * " + ], + [ + "Aver", + "age" + ], + [ + "Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev ", + "Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\"" + ], + [ + "https://github.com/ethereum/solidity", + "/" + ], + [ + "() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol", + "() public view virtual override returns (string memory) {\\n return _symbol" + ], + [ + " ", + "{\\n function " + ], + [ + "rac", + "tion" + ], + [ + "account", + ".\\n *\\n * " + ], + [ + "lo", + "an" + ], + [ + "check", + "ed " + ], + [ + "] ", + ": " + ], + [ + "sign", + "ed by the " + ], + [ + "il", + "it" + ], + [ + "] = ", + "approved" + ], + [ + "to, ", + "tokenId" + ], + [ + "must be ", + "owned by `from" + ], + [ + "Updat", + "e " + ], + [ + "Enumer", + "able " + ], + [ + "extension", + "\\n * @dev See https://eips.ethereum.org/EIPS/eip-721" + ], + [ + "we ", + "check " + ], + [ + ");\\n\\n /**\\n * @dev Returns the ", + "number of tokens in " + ], + [ + ");\\n\\n /**\\n * @dev Returns the ", + "owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf" + ], + [ + "writ", + "e " + ], + [ + "Hold", + "ers" + ], + [ + "Cop", + "y " + ], + [ + "Default", + "OperatorFilterer" + ], + [ + "assets", + ".\\n */\\n event " + ], + [ + "▒▒", + "▒▒" + ], + [ + "Stak", + "ing" + ], + [ + "amount exceeds balance\\\");\\n unchecked {\\n ", + "_balances[account] = accountBalance - amount" + ], + [ + "tryRecover(hash", + ", v, r, s" + ], + [ + "govern", + "ance" + ], + [ + ") external;\\n\\n /**\\n * @dev Returns the ", + "account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name", + "() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol" + ], + [ + "All two ", + "of these values are immutable: they can only be set once during\\n * construction" + ], + [ + "optional metadata functions from the ERC20 standard", + ".\\n *\\n * _Available since v4.1._" + ], + [ + "bytes(baseURI", + ").length" + ], + [ + "(uint256 tokenId) external view returns (address owner", + ");\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to" + ], + [ + "produces ", + "hash " + ], + [ + "`) `operator` to manage all of its ", + "assets.\\n */\\n event " + ], + [ + "account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance", + ");\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf" + ], + [ + "optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._", + "\\n */\\ninterface " + ], + [ + "account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf", + "(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to" + ], + [ + "\"", + "Trading " + ], + [ + ")", + "), " + ], + [ + ";", + "\\r\\n " + ], + [ + "i", + "li" + ], + [ + "p", + "hase" + ], + [ + "y", + "et " + ], + [ + "s ", + "guidelines: functions " + ], + [ + "uint256", + "[] " + ], + [ + "ed ", + "as " + ], + [ + "er ", + "= " + ], + [ + "sign", + "ator" + ], + [ + ", \\\"", + "!" + ], + [ + ") internal pure returns (", + "address, " + ], + [ + "au", + "g" + ], + [ + "sc", + "ale" + ], + [ + "OpenZeppelin Contract", + "s guidelines: functions " + ], + [ + "marketing", + "FeeReceiver" + ], + [ + "`]", + "\\n * " + ], + [ + "deploy", + "ment" + ], + [ + "_N", + "AM" + ], + [ + "maxWallet", + "Amount" + ], + [ + "ERC721 ", + "token " + ], + [ + "automatedMarketMakerPair", + "s[" + ], + [ + "} and {", + "revokeRole" + ], + [ + "functionDelegateCall", + "(target, data, \\\"Address: low-level " + ], + [ + "\\n */\\ninterface ", + "IERC721" + ], + [ + "(uint256 tokenId) external view returns (", + "string memory" + ], + [ + "grantRole", + "} and {revokeRole" + ], + [ + ".\\n */\\n event Transfer(address indexed from, address indexed to, uint256 ", + "indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables " + ], + [ + ".\\n */\\n event Approval(address indexed owner, address indexed ", + "approved, uint256 " + ], + [ + "(account, address(0), amount);\\n\\n ", + "_afterTokenTransfer" + ], + [ + ";\\n // ", + "Overflow not possible: " + ], + [ + "indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables ", + "or " + ], + [ + "was", + "\\n * " + ], + [ + "Insufficient", + " " + ], + [ + "instead ", + "returning `false` on failure. This behavior is nonethel" + ], + [ + "\\n //////////////////////////////////////////////////////////////*/", + "\\n\\n " + ], + [ + "and does not conflict with the expectations of ", + "ERC20" + ], + [ + "throwError(", + "error" + ], + [ + ")\\\", p0));\\n\\t}\\n\\n\\tfunction ", + "logBytes" + ], + [ + "igno", + "re" + ], + [ + ";\\n\\n /**\\n * @dev Sets the values for {name} and {symbol", + "}.\\n *\\n * " + ], + [ + "provides ", + "an " + ], + [ + "Collection of functions related to the address type\\n */\\nlibrary Address ", + "{\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * " + ], + [ + "tog", + "ether " + ], + [ + "ApprovalForAll(address indexed owner, address indexed operator, bool approved", + ");\\n\\n /**\\n * @dev Returns the number of tokens in " + ], + [ + "Emitted when `tokenId` token is ", + "transferred from `from` to `to`" + ], + [ + "`approved` to manage the `tokenId` token", + ".\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 " + ], + [ + "(uint256 tokenId) external view returns (address operator", + ");\\n\\n /**\\n * @dev " + ], + [ + "(address recovered, ", + "RecoverError error) = " + ], + [ + "conventional ", + "and does not conflict with the expectations of ERC20" + ], + [ + ") external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved", + "(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev " + ], + [ + "`) `operator` to manage all of its assets.\\n */\\n event ", + "ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in " + ], + [ + ") internal pure returns (address, ", + "RecoverError" + ], + [ + "OpenZeppelin Contracts guidelines: functions ", + "revert" + ], + [ + "functionDelegateCall(target, data, \\\"Address: low-level ", + "delegate " + ], + [ + ".\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables ", + "`approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 " + ], + [ + "instead returning `false` on failure. This behavior is nonethel", + "ess" + ], + [ + ".\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 ", + "indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or " + ], + [ + "(", + "see {" + ], + [ + "P", + "ur" + ], + [ + "c", + "ould " + ], + [ + "x", + " * " + ], + [ + "public", + "Sale" + ], + [ + "byt", + "ecode" + ], + [ + "op", + "y" + ], + [ + "value ", + "stored at position `index` " + ], + [ + "== ", + "1" + ], + [ + ";\\n\\n ", + "constructor(" + ], + [ + ").", + "\\r\\n *\\r\\n * " + ], + [ + "Rol", + "es are " + ], + [ + "deleg", + "ation" + ], + [ + "result", + "Ptr" + ], + [ + "Set ", + "{\\n " + ], + [ + "_tax", + "FeeOnSell" + ], + [ + "ST", + " " + ], + [ + "emit Transfer", + "(address(0), account, amount);\\n\\n " + ], + [ + "addedValue", + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n " + ], + [ + "mload", + "(0x" + ], + [ + "to a ", + "set. O(1).\\n *\\n * Returns true if the value was " + ], + [ + " not ", + "been already " + ], + [ + "Returns true if the ", + "value is " + ], + [ + "interfaces", + "/contracts/" + ], + [ + "case", + "s " + ], + [ + "grantRole", + "} " + ], + [ + ".call{value: ", + "amount" + ], + [ + "granted `role`, emits a {Role", + "Granted" + ], + [ + "set, that is if it ", + "was not\\n * already " + ], + [ + "set, that is if it ", + "was\\n * " + ], + [ + "set. O(1).\\n *\\n * Returns true if the value was ", + "removed from the " + ], + [ + "added to the ", + "set, that is if it was not\\n * already " + ], + [ + "a value ", + "to a set. O(1).\\n *\\n * Returns true if the value was " + ], + [ + "Counters.", + "Counter" + ], + [ + ".\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply ", + "+= amount;\\n " + ], + [ + "writt", + "en " + ], + [ + "/**\\r", + "\\n * @dev " + ], + [ + "imil", + "ar" + ], + [ + "Removes a value from a ", + "set. O(1).\\n *\\n * Returns true if the value was removed from the " + ], + [ + ";\\n }\\n\\n /**\\n * @dev Add ", + "a value to a set. O(1).\\n *\\n * Returns true if the value was " + ], + [ + "optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface ", + "IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8" + ], + [ + "Emitted when `tokenId` token is transferred from `from` to `to`", + ".\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or " + ], + [ + "emit Transfer(address(0), account, amount);\\n\\n ", + "_afterTokenTransfer" + ], + [ + " not been already ", + "granted `role`, emits a {RoleGranted" + ], + [ + "Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the ", + "set, that is if it was\\n * " + ], + [ + ";\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was ", + "added to the set, that is if it was not\\n * already " + ], + [ + "4", + "5" + ], + [ + "I", + "Vault" + ], + [ + "L", + "z" + ], + [ + "_", + "VERSION" + ], + [ + ", ", + "a " + ], + [ + "ac", + "ter" + ], + [ + "ac", + "opy" + ], + [ + "owner", + " != address(0), \\\"" + ], + [ + "\\n *", + " " + ], + [ + "dat", + "acopy" + ], + [ + ") {\\n ", + "uint256 " + ], + [ + "Addres", + "s = " + ], + [ + "Address", + ".sol\"" + ], + [ + "The ", + "maximum " + ], + [ + "\\r\\n ", + "{\\r\\n " + ], + [ + "col", + "lect" + ], + [ + ") public view virtual ", + "override returns (bool) {\\n return _" + ], + [ + "_token", + "URI" + ], + [ + "Registr", + "y " + ], + [ + "BP", + "T " + ], + [ + "s\\n ", + "mapping(address => " + ], + [ + "For example", + ":\\n *\\n * " + ], + [ + "`.\\n *\\n * This ", + "internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer" + ], + [ + "-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall", + "(address target, bytes memory data) internal returns (bytes memory) {\\n return " + ], + [ + "nft ", + "contract" + ], + [ + "_approve(_msgSender(), spender, ", + "_allowances[_msgSender()][spender" + ], + [ + "blockTimestamp", + "Last" + ], + [ + "pull", + "/" + ], + [ + "(\\n address operator", + ",\\n address from" + ], + [ + "nonc", + "es[" + ], + [ + "Creator: Chiru Labs", + "\\n\\npragma solidity ^0.8.4" + ], + [ + ",", + "string " + ], + [ + "F", + "ir" + ], + [ + "I", + "f" + ], + [ + "O", + "ri" + ], + [ + "f", + "c" + ], + [ + "p", + "256" + ], + [ + "}", + "\\r\\n " + ], + [ + "es", + "\\n * " + ], + [ + "a ", + "set of " + ], + [ + "value", + "}" + ], + [ + "Cont", + "roller" + ], + [ + "min", + "(" + ], + [ + "Rou", + "ter " + ], + [ + ") internal pure returns (", + "address) {\\n " + ], + [ + "Tim", + "e = " + ], + [ + "transfer ", + "caller is not owner nor approved" + ], + [ + "result", + " * " + ], + [ + "}.", + "\\r\\n */\\r\\n function " + ], + [ + "read", + " " + ], + [ + "ERC721A", + ": " + ], + [ + "verify", + "ingContract" + ], + [ + " bits", + "\\\"" + ], + [ + "approved ", + "address" + ], + [ + "Base", + "Pool" + ], + [ + "into ", + "a " + ], + [ + "price", + "0" + ], + [ + "price", + "1" + ], + [ + "BITPOS", + "_AUX" + ], + [ + "Factor", + "y " + ], + [ + "(address owner, address spender", + ", uint256 amount" + ], + [ + "math", + " " + ], + [ + "has been ", + "transferred to `to`.\\n * - when `from` is zero, `amount` " + ], + [ + "sec", + "p256" + ], + [ + "support ", + "for " + ], + [ + "queri", + "ed " + ], + [ + ") internal view returns (bool", + ") {\\n return _" + ], + [ + "burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _", + "afterTokenTransfer" + ], + [ + "set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account", + "` cannot be the zero address" + ], + [ + "tokens have been ", + "burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer" + ], + [ + "Comput", + "e the " + ], + [ + "Library", + "." + ], + [ + ")) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol", + ";\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * " + ], + [ + "Swa", + "pped" + ], + [ + "(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n ", + "uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn " + ], + [ + "Rele", + "ase" + ], + [ + "_AM", + "OUNT" + ], + [ + "\"TOKEN", + ": " + ], + [ + "has been transferred to `to`.\\n * - when `from` is zero, `amount` ", + "tokens have been " + ], + [ + "secp256", + "k" + ], + [ + "_", + "contract" + ], + [ + "{", + "tokenURI" + ], + [ + "it", + "eration" + ], + [ + "co", + "st " + ], + [ + "a ", + "valid " + ], + [ + "ing ", + "and " + ], + [ + "us", + "ed by " + ], + [ + "bytes32", + ") {\\n return _" + ], + [ + ");\\n\\n ", + "// =============================================================\\n // " + ], + [ + "Mint", + " " + ], + [ + "override ", + "{" + ], + [ + "********", + "****" + ], + [ + "String", + "s for uint256" + ], + [ + "unchecked {\\n ", + "return " + ], + [ + "approval", + "Check" + ], + [ + "gener", + "ated " + ], + [ + ") / ", + "b" + ], + [ + "int256 ", + "constant " + ], + [ + "Al", + "loc" + ], + [ + "optim", + "ization" + ], + [ + "MaxWallet", + "Amount" + ], + [ + "' ", + "value" + ], + [ + "buil", + "d" + ], + [ + "Max ", + "wallet " + ], + [ + "the calling ", + "account.\\n *\\n * " + ], + [ + "Sc", + "al" + ], + [ + ".sol\\\";\\n\\n/**\\n * @title ", + "ERC-721 Non-Fungible Token Standard, " + ], + [ + "`account`.\\n *\\n * If `account` had", + " not been already granted `role`, emits a {RoleGranted" + ], + [ + "address data", + ".\\n uint256 private constant _" + ], + [ + "a == ", + "b" + ], + [ + "iev", + "e " + ], + [ + ");\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` ", + "set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address" + ], + [ + "for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator", + ", bool _approved" + ], + [ + "functionDelegateCall(target, data, \\\"Address: low-level delegate ", + "call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string" + ], + [ + "`account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted", + "}\\n * event" + ], + [ + ")", + "\\n * " + ], + [ + ",", + "\\r\\n " + ], + [ + "1", + ", " + ], + [ + "7", + "5" + ], + [ + "a", + "a" + ], + [ + "h", + "o" + ], + [ + "ro", + "s" + ], + [ + "at", + "ed in " + ], + [ + "amount", + " to be transferred" + ], + [ + ".s", + "lot " + ], + [ + "Mint", + "Amount" + ], + [ + "Per", + "Share" + ], + [ + ".\\n * ", + "@param _" + ], + [ + "number", + "Minted " + ], + [ + "vari", + "ables " + ], + [ + "total ", + "supply " + ], + [ + "== 0", + ") revert Mint" + ], + [ + "sqrt", + "(" + ], + [ + "kn", + "ow " + ], + [ + ",uint256 ", + "nonce" + ], + [ + "}\\n }\\n\\n ", + "// =============================================================\\n // " + ], + [ + "TokenOwnership ", + "memory" + ], + [ + "\\n *", + "\\n * " + ], + [ + "hand", + "le" + ], + [ + "/*//////////////////////////////////////////////////////////////", + "\\n " + ], + [ + "voting", + "Power" + ], + [ + "Ethereum Signed Message", + ":" + ], + [ + "information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals", + "() public view virtual override returns (uint8) {\\n return 18" + ], + [ + "Grants `role` to ", + "`account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol", + ";\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5" + ], + [ + "-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return ", + "functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string" + ], + [ + "-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string", + "-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall" + ], + [ + ")", + " * " + ], + [ + "1", + "c" + ], + [ + ") ", + "of " + ], + [ + "se", + "e" + ], + [ + "Token", + "Gated" + ], + [ + "ERC20", + "(\\\"" + ], + [ + "if", + "ication" + ], + [ + "value", + ", \\\"SafeCast: value doesn't fit in " + ], + [ + "ch", + "arg" + ], + [ + "add", + "(_" + ], + [ + "s.", + "\\n " + ], + [ + "== ", + "value, \\\"SafeCast: value doesn't fit in " + ], + [ + "Approval", + "QueryForNonexistentToken" + ], + [ + "Approval", + "CallerNotOwnerNorApproved" + ], + [ + "Allowanc", + "e = " + ], + [ + ");\\n return ", + "recovered" + ], + [ + ";\\n }\\n\\n ", + "struct " + ], + [ + "Deleg", + "ation" + ], + [ + ");\\n _", + "throwError(error" + ], + [ + "fl", + "ation" + ], + [ + "ST", + "RUCT" + ], + [ + "them", + ".\\n *\\n * " + ], + [ + " {\\n /**\\n * @dev ", + "Emitted when " + ], + [ + "(account", + ", amount" + ], + [ + "downcast", + "ed = " + ], + [ + "Multi", + "pl" + ], + [ + "downcasted ", + "== value, \\\"SafeCast: value doesn't fit in " + ], + [ + "rati", + "o " + ], + [ + "Pric", + "e(" + ], + [ + "index ", + "out of bound" + ], + [ + "otherwis", + "e" + ], + [ + "Af", + "ter " + ], + [ + "TransferTo", + "ZeroAddress" + ], + [ + "_setup", + "Decimals" + ], + [ + "Implementation of the {", + "IERC165" + ], + [ + "() external pure returns (", + "address" + ], + [ + "address that ", + "will receive the " + ], + [ + "TransferFrom", + "Incorrect" + ], + [ + "redemp", + "tion" + ], + [ + ");\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev ", + "Moves `amount` of tokens from " + ], + [ + "off-", + "chain " + ], + [ + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n // ", + "(a + b" + ], + [ + "from != address(0), \\\"ERC20: ", + "transfer from the zero address\\\");\\n require(" + ], + [ + "a role", + "'s " + ], + [ + "extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721", + "\\n */\\ninterface IERC721" + ], + [ + "All two of these values are immutable: they can only be set once during\\n * construction", + ".\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_" + ], + [ + ") internal pure returns (address) {\\n ", + "(address recovered, RecoverError error) = " + ], + [ + ");\\n return recovered", + ";\\n }\\n\\n /**\\n * @dev " + ], + [ + ");\\n _throwError(error", + ");\\n return recovered;\\n }\\n\\n /**\\n * @dev " + ], + [ + " ", + "by " + ], + [ + " ", + "|| " + ], + [ + "-", + "` operator.\\n *\\n * Requirements:\\n *\\n * - " + ], + [ + "3", + "e" + ], + [ + "_", + "reward" + ], + [ + "_", + "implementation" + ], + [ + " ", + "- " + ], + [ + "ti", + "er" + ], + [ + "im", + "ent" + ], + [ + "ul", + "l" + ], + [ + "over", + "load" + ], + [ + ". ", + "Al" + ], + [ + "new", + "Admin" + ], + [ + "IERC20", + ".sol\\\";\\n\\n/**\\n * @dev Interface for the " + ], + [ + ", p", + "re" + ], + [ + "atu", + "re " + ], + [ + " is ", + "the " + ], + [ + "!= ", + "type(uint256).max" + ], + [ + "uniswapV2Router", + "." + ], + [ + "&&", + "\\n " + ], + [ + "IERC165", + ".sol\\\";\\n\\n/**\\n * @dev " + ], + [ + "dig", + "it" + ], + [ + "(value", + "))" + ], + [ + "AD", + "DRESS" + ], + [ + "token/ERC721/", + "ERC721" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0", + ";\\n\\nimport \\\"../" + ], + [ + "upgrade", + "To" + ], + [ + "automa", + "tically " + ], + [ + "_new", + "Fee" + ], + [ + "Sy", + "mbol" + ], + [ + "NSF", + "ER" + ], + [ + "chil", + "d " + ], + [ + "} interface.\\n *\\n * ", + "Contract" + ], + [ + ".call{value: ", + "value}" + ], + [ + ",\\n bytes calldata data", + "\\n ) external returns (" + ], + [ + "Spl", + "itter" + ], + [ + "until", + " " + ], + [ + "- subtractedValue", + ");\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves `amount` of tokens from " + ], + [ + " of two unsigned integers, reverting on\\n * overflow.\\n *\\n * ", + "Counterpart to Solidity's `" + ], + [ + "one signed ", + "with the\\n * " + ], + [ + "`]\\n * ", + "JSON-RPC method as part of EIP-" + ], + [ + "(account, address(0), amount);\\n\\n _afterTokenTransfer", + "(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve" + ], + [ + "Pur", + "ch" + ], + [ + ",uint256 nonce", + ",uint256 " + ], + [ + "from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(", + "to != address(0), \\\"ERC20: " + ], + [ + "(", + "uint amountOut" + ], + [ + "2", + "9" + ], + [ + "G", + "SN" + ], + [ + "_", + "balance" + ], + [ + "_", + "supply" + ], + [ + "l", + "isting" + ], + [ + ") ", + "| " + ], + [ + "token", + "Approval" + ], + [ + "return ", + "interfaceId == type(" + ], + [ + "its ", + "subscription" + ], + [ + "Balance", + "QueryForZeroAddress" + ], + [ + ",\\n uint256 ", + "deadline" + ], + [ + "(_", + "tokenId" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Returns the ", + "subtraction" + ], + [ + "}\\n\\n ", + "return " + ], + [ + "####", + "##" + ], + [ + "(\\n address from,\\n address to,\\n uint256 tokenId", + ",\\n bytes memory _data\\n " + ], + [ + "when", + "Paused" + ], + [ + "bytes4 ", + "retval" + ], + [ + "manag", + "ed by " + ], + [ + "utils/introspection/IERC165", + ".sol\"" + ], + [ + "  ", + "  " + ], + [ + "onlyAllowedOperator", + "Approval" + ], + [ + ">= amount, \\\"ERC20: transfer ", + "amount exceeds balance\\\");\\n unchecked {\\n " + ], + [ + ")\\n public\\n view", + "\\n virtual\\n override" + ], + [ + "(bool success, ) = recipient", + ".call{value: amount" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role", + ".\\n */\\n function " + ], + [ + "exper", + "iment" + ], + [ + "Implementation of the {IERC165", + "} interface.\\n *\\n * Contract" + ], + [ + "-` operator.\\n *\\n * Requirements:\\n *\\n * - ", + "Subtraction cannot overflow.\\n */\\n function sub" + ], + [ + " ", + "as " + ], + [ + ")", + "`" + ], + [ + "S", + "Y" + ], + [ + "]", + ", \\\"" + ], + [ + "acc", + "umul" + ], + [ + "returns (bool", + ") {\\r\\n " + ], + [ + "pack", + " " + ], + [ + "reserve", + "B" + ], + [ + "19", + "8" + ], + [ + "\\n *", + "\\n * @dev " + ], + [ + "\\n //", + "\\n // " + ], + [ + "Di", + "vide " + ], + [ + "ord", + "in" + ], + [ + ".\\n */\\nabstract contract ", + "ERC165" + ], + [ + "Bot", + "s" + ], + [ + "mean", + "s " + ], + [ + ") {\\n ", + "return " + ], + [ + "minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s ", + "tokens have been burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer" + ], + [ + "2,\\n 2,\\n ", + "2,\\n 2,\\n " + ], + [ + "any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * ", + "has been transferred to `to`.\\n * - when `from` is zero, `amount` tokens have been " + ], + [ + "er to ", + "use " + ], + [ + "Und", + "erflow" + ], + [ + ") public payable ", + "virtual " + ], + [ + "string(abi.encodePacked(", + "baseURI, " + ], + [ + "Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be ", + "transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer" + ], + [ + ",\\n address[] calldata path", + ",\\n address to,\\n uint deadline" + ], + [ + "LOO", + "KS" + ], + [ + "All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_", + ";\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5" + ], + [ + "any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * has been transferred to `to`.\\n * - when `from` is zero, `amount` tokens have been ", + "minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer" + ], + [ + "(", + "role" + ], + [ + "-", + "st" + ], + [ + "1", + "f" + ], + [ + "A", + "4" + ], + [ + "D", + "ate" + ], + [ + "`", + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be " + ], + [ + "p", + "c" + ], + [ + "en", + "able " + ], + [ + "// ", + "F" + ], + [ + "sp", + "ac" + ], + [ + "ai", + "d" + ], + [ + "Ma", + "ke " + ], + [ + "(\\n ", + "bool success" + ], + [ + "\\n ", + "function " + ], + [ + "IERC721", + ".sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, " + ], + [ + "com", + "pa" + ], + [ + "functionCall", + "(target, data, \\\"Address: low-level " + ], + [ + "exceed", + "s " + ], + [ + "gener", + "ates " + ], + [ + "dig", + "its " + ], + [ + "tern", + "ativel" + ], + [ + "subscri", + "b" + ], + [ + "(bytes32 ", + "=> " + ], + [ + "verifyCallResult", + "(\\n bool success" + ], + [ + "/// @", + "title " + ], + [ + "Over", + "ri" + ], + [ + "enti", + "al" + ], + [ + "this contract ", + "and " + ], + [ + "EIP712", + "Domain" + ], + [ + "\"@openzeppelin/contracts/utils/", + "Strings.sol\"" + ], + [ + "fic", + "tiveReserve" + ], + [ + "realis", + "tically " + ], + [ + "char", + "act" + ], + [ + " != 0", + ") {\\n " + ], + [ + "retval", + " == " + ], + [ + "ERC20-", + "_burn" + ], + [ + " bits\\n *\\n * _Available since v4.7._\\n */\\n function ", + "toInt" + ], + [ + "lower than ", + "0." + ], + [ + ") internal virtual {}\\n\\n /**\\n * @dev Hook that is called after ", + "any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * has been transferred to `to`.\\n * - when `from` is zero, `amount` tokens have been minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer" + ], + [ + ".startTimestamp", + " = " + ], + [ + "verify ", + "that a " + ], + [ + "art", + "blocks" + ], + [ + "}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function ", + "transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n " + ], + [ + " <<", + " (" + ], + [ + "string memory baseURI", + " = _baseURI" + ], + [ + "https://github.com/ethereum/solidity/", + "issues/" + ], + [ + "optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8", + ");\\n}\\n\"" + ], + [ + ");\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address", + ".\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n " + ], + [ + "information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18", + ";\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `" + ], + [ + "`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be ", + "owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this " + ], + [ + "ternativel", + "y, " + ], + [ + "%", + " or " + ], + [ + "-", + "bit " + ], + [ + ".", + "isContract" + ], + [ + "D", + "0" + ], + [ + "_", + "addr" + ], + [ + "a", + "z" + ], + [ + "b", + "f" + ], + [ + "f", + "ra" + ], + [ + "m", + "igr" + ], + [ + "s", + "ample" + ], + [ + "uint", + "40" + ], + [ + ", ", + "then " + ], + [ + "\\n * ", + "message unnecessarily. For custom revert reasons use {" + ], + [ + "token", + "Owner" + ], + [ + "co", + "der" + ], + [ + "ext", + "ension " + ], + [ + "Token", + ".sol\"" + ], + [ + " ", + " " + ], + [ + "\\n * ", + "conventional and does not conflict with the expectations of ERC20" + ], + [ + "\\n * ", + "instead returning `false` on failure. This behavior is nonetheless" + ], + [ + ",\\n ", + "uint liquidity" + ], + [ + "open", + "Trading" + ], + [ + "\\n // ", + "- " + ], + [ + "_transfer", + "From" + ], + [ + "uint256) {\\n ", + "uint256 " + ], + [ + "][", + "_msgSender()" + ], + [ + "MIN", + "_INT256" + ], + [ + "s that ", + "want to " + ], + [ + "your ", + "contract" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n", + "pragma solidity 0.6." + ], + [ + "feeTo", + "Setter" + ], + [ + "Multip", + "lier" + ], + [ + "\"Cannot ", + "set " + ], + [ + "Holding", + "Amount" + ], + [ + "```solidity", + "\\n * function " + ], + [ + "whitelist ", + "mint " + ], + [ + "data to ", + "send " + ], + [ + "CAUTION: This function is deprecated because it requires allocating memory for the error", + "\\n * message unnecessarily. For custom revert reasons use {" + ], + [ + "OpenZeppelin Contracts guidelines: functions revert", + "\\n * instead returning `false` on failure. This behavior is nonetheless" + ], + [ + "emit Transfer(address(0), account, amount);\\n\\n _afterTokenTransfer", + "(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn " + ], + [ + ".slot ", + ":= " + ], + [ + "realistically ", + "overflow" + ], + [ + "\\n * conventional and does not conflict with the expectations of ERC20", + "\\n * " + ], + [ + "OpenZeppelin Contracts guidelines: functions revert\\n * instead returning `false` on failure. This behavior is nonetheless", + "\\n * conventional and does not conflict with the expectations of ERC20\\n * " + ], + [ + "emit Transfer(address(0), account, amount);\\n\\n _afterTokenTransfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn ", + "amount exceeds balance\\\");\\n unchecked {\\n _balances[account] = accountBalance - amount" + ], + [ + "\"", + "B" + ], + [ + "P", + "AUS" + ], + [ + "_", + "default" + ], + [ + "g", + "obbl" + ], + [ + "\\n ", + "//\\n // " + ], + [ + ", ", + "0, " + ], + [ + "ex", + "pres" + ], + [ + "a ", + "target " + ], + [ + "account", + "'s " + ], + [ + "Am", + "p" + ], + [ + "} ", + "provides an " + ], + [ + "totalSupply", + "_" + ], + [ + "bytes memory ", + "reason" + ], + [ + "point", + "er" + ], + [ + "En", + "coder" + ], + [ + "██", + "█" + ], + [ + "UniswapV2", + "Router" + ], + [ + ", and ", + "then " + ], + [ + "but ", + "more expensive " + ], + [ + "should ", + "inherit from " + ], + [ + "for the ", + "additional " + ], + [ + "implement ", + "ERC165 " + ], + [ + "`from` to ", + "`to` " + ], + [ + "stak", + "ed" + ], + [ + "ain ", + "`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall" + ], + [ + "royalty", + "Amount" + ], + [ + "RoleAdmin", + "Changed" + ], + [ + "supportsInterface", + "} to " + ], + [ + "Al", + "ternatively, " + ], + [ + "Storage", + "} provides an " + ], + [ + "\\n * ", + "return interfaceId == type(" + ], + [ + "supportsInterface(bytes4 interfaceId) public view virtual ", + "override returns (bool) {" + ], + [ + "% ", + "total supply" + ], + [ + "BITPOS_N", + "EXT_INITIALIZED" + ], + [ + "Interface", + ").interfaceId || super.supportsInterface(interfaceId" + ], + [ + "Bl", + "ack" + ], + [ + "AA", + "AA" + ], + [ + "easi", + "er to use " + ], + [ + " */", + "\\r\\n function " + ], + [ + "Wrapp", + "ed" + ], + [ + "// solhint-disable-next-line ", + "avoid-low-level-call" + ], + [ + "{ERC165", + "Storage} provides an " + ], + [ + "My", + "Interface).interfaceId || super.supportsInterface(interfaceId" + ], + [ + "_redis", + "FeeOnSell" + ], + [ + "Base ", + "URI for " + ], + [ + "ERC721A ", + "Contract" + ], + [ + "EVENT", + "_SIGNATUR" + ], + [ + "FX", + "S" + ], + [ + "that will be ", + "supported. " + ], + [ + "does not exist", + ".\\n */\\n error " + ], + [ + "();\\n\\n /**\\n * The token ", + "does not exist.\\n */\\n error " + ], + [ + "interface id ", + "that will be supported. " + ], + [ + "_TRA", + "NSFER_" + ], + [ + "ABI", + "Encoder" + ], + [ + ", IERC20Metadata {\\n ", + "mapping(address => uint256) private _balances;\\n\\n mapping(address => mapping(address => uint256" + ], + [ + "override {", + "supportsInterface} to " + ], + [ + "this contract and ", + "override {supportsInterface} to " + ], + [ + "% or ", + "less" + ], + [ + "s that want to ", + "implement ERC165 " + ], + [ + "but more expensive ", + "implementation" + ], + [ + "should inherit from ", + "this contract and override {supportsInterface} to " + ], + [ + "for the additional ", + "interface id that will be supported. " + ], + [ + "Alternatively, ", + "{ERC165Storage} provides an " + ], + [ + "\\n * return interfaceId == type(", + "MyInterface).interfaceId || super.supportsInterface(interfaceId" + ], + [ + "easier to use ", + "but more expensive implementation" + ], + [ + "ABIEncoder", + "V2" + ], + [ + "s that want to implement ERC165 ", + "should inherit from this contract and override {supportsInterface} to " + ], + [ + "Alternatively, {ERC165Storage} provides an ", + "easier to use but more expensive implementation" + ], + [ + "\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId", + ");" + ], + [ + "s that want to implement ERC165 should inherit from this contract and override {supportsInterface} to ", + "check" + ], + [ + " ", + "that " + ], + [ + "/", + "ethereum" + ], + [ + "3", + "00" + ], + [ + "_", + "fees" + ], + [ + "`", + "address" + ], + [ + "e", + "-" + ], + [ + "y", + "ou" + ], + [ + "de", + "termin" + ], + [ + "bl", + "ack" + ], + [ + "pp", + "er" + ], + [ + "amount", + "ADesired" + ], + [ + "To", + "Address" + ], + [ + "or ", + "the " + ], + [ + "ERC20", + "Votes" + ], + [ + "In", + "put" + ], + [ + "and ", + "transfers " + ], + [ + "} ", + "catch" + ], + [ + "pro", + "tection" + ], + [ + "require(", + "\\n " + ], + [ + "ha", + "ve" + ], + [ + "Mint", + "Validation" + ], + [ + "safe", + "In" + ], + [ + "; ", + "++i" + ], + [ + "_approve", + "(sender" + ], + [ + "start", + "Time" + ], + [ + "lea", + "f " + ], + [ + "OT", + "AL" + ], + [ + "\"@openzeppelin/contracts/", + "token/ERC20/ERC20.sol\"" + ], + [ + "number of ", + "whitelist mint " + ], + [ + "src", + "Address" + ], + [ + "approve ", + "to " + ], + [ + "`.\\n */\\n function ", + "get" + ], + [ + "reserve", + "A" + ], + [ + "registr", + "y/" + ], + [ + ")\\n ", + "}\\n " + ], + [ + "values", + "(" + ], + [ + "auto", + "Liquidity" + ], + [ + "author", + "ized " + ], + [ + "amountB", + "Desired" + ], + [ + "46", + "c" + ], + [ + "tokenIds", + "MaxLength" + ], + [ + "() external view returns (string memory);\\n\\n /**\\n * @dev Returns the ", + "token collection symbol" + ], + [ + "/src/", + "\"" + ], + [ + "along with ", + "the call" + ], + [ + ".\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value", + ",\\n string memory errorMessage\\n " + ], + [ + "(e.g. ", + "number of whitelist mint " + ], + [ + "bytes1", + "(uint8(" + ], + [ + "token collection name.\\n */\\n function name", + "() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol" + ], + [ + "call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall", + "(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n " + ], + [ + "slots ", + "used" + ], + [ + "When", + "ever " + ], + [ + "currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero", + "\\\");\\n unchecked {\\n " + ], + [ + "operate ", + "on " + ], + [ + "IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the ", + "optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\"" + ], + [ + "verifyCallResult(\\n bool success", + ",\\n bytes memory returndata,\\n string memory errorMessage\\n " + ], + [ + "data to send ", + "along with the call" + ], + [ + "} catch", + " (" + ], + [ + "(e.g. number of whitelist mint ", + "slots used" + ], + [ + "(", + "\\n " + ], + [ + "B", + "6" + ], + [ + "se", + "s " + ], + [ + "\\n * ", + "for the additional interface id that will be supported. " + ], + [ + "Am", + "t" + ], + [ + ";\\n ", + "} else {\\n return " + ], + [ + " of ", + "an " + ], + [ + "Val", + "ue " + ], + [ + "id", + "_" + ], + [ + "/contracts/", + "interfaces/" + ], + [ + ";\\n ", + "bool public " + ], + [ + "Un", + "i" + ], + [ + "revert ", + "if it " + ], + [ + "Per", + "Tx" + ], + [ + "overflow", + " is " + ], + [ + "data ", + "is " + ], + [ + "`account", + "`" + ], + [ + "account ", + "that " + ], + [ + "() ", + "<= " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Returns the ", + "number of " + ], + [ + "operation", + "s " + ], + [ + ");\\n return true", + ";\\n }\\n\\n function " + ], + [ + "if (!", + "_exists(tokenId" + ], + [ + "Tokens ", + "can be " + ], + [ + "author", + "ization" + ], + [ + "46", + "26" + ], + [ + "AB", + "LE" + ], + [ + "\"@", + "balancer-labs/v2-" + ], + [ + "(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ", + ") internal view returns (bytes memory" + ], + [ + "-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall", + "(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory" + ], + [ + ".\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the ", + "Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI" + ], + [ + "nextTokenId ", + "= " + ], + [ + "safeTransferFrom(from, to, tokenId", + ", ''" + ], + [ + "Modifier ", + "to " + ], + [ + "\\n * }\\n * ```\\n *\\n * ", + "Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation" + ], + [ + ")\\n }\\n ", + "} else {\\n " + ], + [ + "_reflect", + "Fee" + ], + [ + "Nomin", + "al" + ], + [ + "must be owned by `from", + "`" + ], + [ + "For example:\\n *\\n * ", + "```solidity\\n * function " + ], + [ + "Implementation of the {IERC165} interface.\\n *\\n * Contract", + "s that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check" + ], + [ + "supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {", + "\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);" + ], + [ + "token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol", + ".\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI" + ], + [ + "call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ", + ") internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`" + ], + [ + "\\n * for the additional interface id that will be supported. ", + "For example:\\n *\\n * ```solidity\\n * function " + ], + [ + "\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation", + ".\\n */\\nabstract contract ERC165" + ], + [ + "Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check", + "\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function " + ], + [ + "supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);", + "\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165" + ], + [ + "token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI", + "(uint256 tokenId) external view returns (string memory" + ], + [ + "Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function ", + "supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165" + ], + [ + "1", + "35" + ], + [ + "2", + "." + ], + [ + "E", + "ach " + ], + [ + "W", + "ord" + ], + [ + ") ", + "||" + ], + [ + "y ", + "/ " + ], + [ + "ed ", + "and " + ], + [ + "pro", + "of " + ], + [ + "as ", + "well" + ], + [ + "approve", + "} or {" + ], + [ + "e {", + "IERC721Receiver-onERC721Received" + ], + [ + "log", + "_" + ], + [ + "\\n // ", + "Look for revert reason and bubble it up if present" + ], + [ + "for", + "\\n // " + ], + [ + "safe", + "Decrease" + ], + [ + "\\n */\\n function ", + "get" + ], + [ + "_msgSender(", + ") == " + ], + [ + "ID", + " of the " + ], + [ + "entr", + "y " + ], + [ + "&&", + " _" + ], + [ + "approved ", + "accounts " + ], + [ + "their ", + "owner or " + ], + [ + "Tokens ", + "start " + ], + [ + "royalty ", + "information" + ], + [ + "nonces", + "(address owner" + ], + [ + "returned ", + "the expected " + ], + [ + "- the ", + "first " + ], + [ + "// The ", + "easiest way to bubble the revert reason is using memory via assembly" + ], + [ + "nextInitialized", + "Flag" + ], + [ + ")) private ", + "_operatorApprovals" + ], + [ + "\\n if (", + "returndata.length" + ], + [ + "via {", + "approve} or {" + ], + [ + ".\\r", + "\\n * - `" + ], + [ + "IERC721Enumerable", + "-" + ], + [ + "_balances[from", + "] = " + ], + [ + "Returns whether ", + "`tokenId` " + ], + [ + ")\\n ", + "revert(add(32, returndata), returndata_size" + ], + [ + "} on ", + "a target " + ], + [ + "invok", + "e {IERC721Receiver-onERC721Received" + ], + [ + "the call ", + "correctly " + ], + [ + "\\n assembly {\\n ", + "let returndata_size := mload(returndata" + ], + [ + "build", + "DomainSeparator" + ], + [ + "managed by ", + "their owner or " + ], + [ + "All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5", + ".0" + ], + [ + ", IERC20Metadata {\\n mapping(address => uint256) private _balances;\\n\\n mapping(address => mapping(address => uint256", + ")) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * " + ], + [ + "/ethereum", + "-" + ], + [ + "Tokens can be ", + "managed by their owner or " + ], + [ + ")\\n }\\n } else {\\n ", + "revert(errorMessage" + ], + [ + "\\n // Look for revert reason and bubble it up if present", + "\\n if (returndata.length" + ], + [ + "approved accounts ", + "via {approve} or {" + ], + [ + "Tokens start ", + "existing when they are " + ], + [ + "returned the expected ", + "magic value" + ], + [ + ")\\n revert(add(32, returndata), returndata_size", + ")\\n }\\n } else {\\n revert(errorMessage" + ], + [ + "invoke {IERC721Receiver-onERC721Received", + "} on a target " + ], + [ + "the call correctly ", + "returned the expected magic value" + ], + [ + "\\n assembly {\\n let returndata_size := mload(returndata", + ")\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage" + ], + [ + "Tokens can be managed by their owner or ", + "approved accounts via {approve} or {" + ], + [ + "Tokens can be managed by their owner or approved accounts via {approve} or {", + "setApprovalForAll" + ], + [ + "A", + "g" + ], + [ + "g", + "or" + ], + [ + "u", + "re " + ], + [ + "an", + "\\n * " + ], + [ + "uint256 ", + "or " + ], + [ + "ri", + "bu" + ], + [ + " = ", + "1 " + ], + [ + "not ", + "exist" + ], + [ + "ETH", + "Fee" + ], + [ + "(\\n ", + "IERC20 token" + ], + [ + ") internal pure returns (", + "int256" + ], + [ + "red ", + "to " + ], + [ + "point", + "s" + ], + [ + "Buy", + "Fee" + ], + [ + ".\\n ", + "_" + ], + [ + "update", + "Swap" + ], + [ + ") {\\n require(", + "isContract(target), \\\"Address: " + ], + [ + "total ", + "amount of tokens " + ], + [ + "ECDSA", + "." + ], + [ + "spender, ", + "value" + ], + [ + "tit", + "le" + ], + [ + "reason", + "), mload(" + ], + [ + "- the ", + "amount to be transferred" + ], + [ + "fees ", + "at " + ], + [ + "ally-", + "ordered " + ], + [ + "enumer", + "ate " + ], + [ + "seri", + "ally-ordered " + ], + [ + "revert(add(32, ", + "reason), mload(" + ], + [ + "bytes32[] memory ", + "proof" + ], + [ + ",\\n uint256 quantity", + "\\n " + ], + [ + " amount ", + "cannot be " + ], + [ + "applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20", + ", IERC20Metadata {\\n mapping(address => uint256) private _balances;\\n\\n mapping(address => mapping(address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * " + ], + [ + "}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * pl", + "ain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall" + ], + [ + ") internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts", + ".\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n " + ], + [ + "-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string", + "-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory" + ], + [ + "operator-filter-", + "registry/" + ], + [ + "See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(", + "IERC165" + ], + [ + "a set of ", + "serially-ordered " + ], + [ + "} catch (", + "bytes memory reason" + ], + [ + "revert(add(32, reason), mload(", + "reason" + ], + [ + "l", + "t(" + ], + [ + "s ", + "`tokenId` " + ], + [ + ", ", + "such as " + ], + [ + "es", + "is" + ], + [ + "ent", + "ri" + ], + [ + "ex", + "act" + ], + [ + "ver", + "y " + ], + [ + ");\\n ", + "}\\n\\n // " + ], + [ + "index", + "]" + ], + [ + "mint", + "Amount" + ], + [ + "Call", + "data" + ], + [ + "pragm", + "a " + ], + [ + "Swap", + " amount cannot be " + ], + [ + ";\\n ", + "uint256 private constant _" + ], + [ + "allowance ", + "is " + ], + [ + "Res", + "ol" + ], + [ + "incre", + "ase " + ], + [ + "Upgrade", + "ability" + ], + [ + "amountIn", + "Max" + ], + [ + "Reentranc", + "y " + ], + [ + "tokenId` must ", + "not exist" + ], + [ + "OU", + "ND" + ], + [ + "An", + "d " + ], + [ + "secur", + "ity " + ], + [ + "} to ", + "enumerate " + ], + [ + "Slot ", + "storage " + ], + [ + "mapping(address => bool", + ") public " + ], + [ + "to != address(0), \\\"", + "ERC721: " + ], + [ + "setApprovalForAll(address operator", + ", bool approved" + ], + [ + "long", + "er " + ], + [ + "verifi", + "es " + ], + [ + "maint", + "ain " + ], + [ + "(bool success, ) = recipient.call{value: amount", + "}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall" + ], + [ + "and transfers ", + "it to " + ], + [ + "s `tokenId` ", + "and transfers it to " + ], + [ + "M", + "erkle " + ], + [ + "{", + "\\n " + ], + [ + "ow", + " the " + ], + [ + "it", + "self " + ], + [ + "/**", + "\\n * " + ], + [ + "return ", + "_tokenApprovals[tokenId" + ], + [ + "on ", + "overflow" + ], + [ + "pa", + "y " + ], + [ + "uint ", + "value" + ], + [ + "com", + "pos" + ], + [ + "implement", + "ed by the " + ], + [ + "allow", + "List" + ], + [ + ";\\n ", + "uint256 " + ], + [ + ";\\n ", + "emit " + ], + [ + ",\\n ", + "_" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// ", + "ERC721A Contract" + ], + [ + "Allow", + "ed(" + ], + [ + "admin", + "istr" + ], + [ + "BITMASK", + "_BURNED" + ], + [ + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev ", + "Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20" + ], + [ + "```", + "\\n * " + ], + [ + "see ", + "https://github.com/ethereum/solidity/issues/" + ], + [ + "flag", + "s" + ], + [ + "ethFor", + "Dev" + ], + [ + "program", + "m" + ], + [ + "and the ", + "recipient" + ], + [ + "solhint-disable-next-line ", + "no-inline-assembly" + ], + [ + "afely ", + "mint" + ], + [ + "whenNot", + "Paused " + ], + [ + "token/ERC20/IERC20", + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20" + ], + [ + "EV", + "M " + ], + [ + "variabl", + "es" + ], + [ + "hashed", + "Version" + ], + [ + "owner to ", + "operator " + ], + [ + "MU", + "ST " + ], + [ + "invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function ", + "mod" + ], + [ + "solidity-utils/", + "contracts/" + ], + [ + "Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n ", + "_transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\"" + ], + [ + "p0) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(", + "bytes" + ], + [ + "es[role].member", + "s[account" + ], + [ + "should only be ", + "called " + ], + [ + "%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * ", + "invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod" + ], + [ + "gor", + "ith" + ], + [ + ") internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ", + ") internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call" + ], + [ + ".", + "\\n " + ], + [ + "3", + "F" + ], + [ + "A", + "7" + ], + [ + "F", + "ail" + ], + [ + ") ", + "return " + ], + [ + "from", + "Balance = " + ], + [ + "ETH", + "Min,\\n address to,\\n uint deadline" + ], + [ + "burn", + "Fee" + ], + [ + "bytes32 ", + "r" + ], + [ + "\\n // ", + "of the " + ], + [ + "\\n// ", + "Creator: Chiru Labs\\n\\npragma solidity ^0.8.4" + ], + [ + ") private ", + "pure " + ], + [ + "owner ", + "address to " + ], + [ + "ReentrancyGu", + "ard " + ], + [ + "calcul", + "ate " + ], + [ + ", either ", + "by bubbl" + ], + [ + "safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId", + ",\\n bytes calldata data" + ], + [ + "_development", + "Address" + ], + [ + "Min,\\n uint amount", + "ETHMin,\\n address to,\\n uint deadline" + ], + [ + "esc", + "row" + ], + [ + "Releas", + "ed" + ], + [ + "you should ", + "overload" + ], + [ + "select a different value ", + "for" + ], + [ + "low level call ", + "was successful, and " + ], + [ + ",\\n uint amountToken", + "Min,\\n uint amountETHMin,\\n address to,\\n uint deadline" + ], + [ + "transfer amount exceeds the ", + "maxTransactionAmount" + ], + [ + "Max wallet ", + "exceed" + ], + [ + ",\\n bytes calldata data\\n ) external returns (", + "bytes4" + ], + [ + "revert if it ", + "was" + ], + [ + "s `tokenId` and transfers it to ", + "`to" + ], + [ + "you should overload", + " it" + ], + [ + "low level call was successful, and ", + "revert if it was" + ], + [ + "8", + "/" + ], + [ + "C", + "y" + ], + [ + "P", + "hase" + ], + [ + "U", + "FF" + ], + [ + "r", + ".slot := " + ], + [ + "us", + "ted " + ], + [ + "sender", + " is not " + ], + [ + ");\\n }\\n\\n /**\\n * @dev ", + "Tool to " + ], + [ + "pa", + "rent" + ], + [ + ".\\n */\\n function _", + "baseURI" + ], + [ + ") internal virtual ", + "override {\\n " + ], + [ + "_mint", + "er" + ], + [ + "AL", + "L" + ], + [ + "ght", + "Early" + ], + [ + ".\\n ", + "uint256 private " + ], + [ + "has", + "Role(role, account" + ], + [ + "requ", + "est " + ], + [ + "option", + "al" + ], + [ + "(uint256 value) internal pure returns (", + "string memory" + ], + [ + "................", + "................" + ], + [ + "librari", + "es/" + ], + [ + "Bytes32", + "Set" + ], + [ + "scalingFactor", + "s" + ], + [ + "Returns an ", + "`" + ], + [ + "ing the\\n * ", + "revert reason " + ], + [ + "If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer", + ".\\n *\\n * Emits a {Transfer} event.\\n */\\n function _" + ], + [ + "filtered ", + "operator" + ], + [ + "missing ", + "role " + ], + [ + "getRoleAdmin", + "(role" + ], + [ + "Process", + "ed" + ], + [ + "computing ", + "{tokenURI" + ], + [ + "venance", + "Hash" + ], + [ + "OpenZeppelin Contracts guidelines: functions revert\\n * instead returning `false` on failure. This behavior is nonetheless\\n * conventional and does not conflict with the expectations of ERC20\\n * ", + "applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping(address => uint256) private _balances;\\n\\n mapping(address => mapping(address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * " + ], + [ + "Base URI for ", + "computing {tokenURI" + ], + [ + "Slot storage ", + "r" + ], + [ + ", either by bubbl", + "ing the\\n * revert reason " + ], + [ + "Base URI for computing {tokenURI", + "}. " + ], + [ + " ", + "=\\n " + ], + [ + "4", + "d" + ], + [ + "l", + "im" + ], + [ + "p", + " < " + ], + [ + "\\n", + "@param " + ], + [ + ") ", + "!= " + ], + [ + "it", + "er" + ], + [ + "bu", + "y " + ], + [ + ".sol", + "ution" + ], + [ + "Pair", + "Created" + ], + [ + "Bu", + "y " + ], + [ + "zeppelin", + ".solution" + ], + [ + "; ", + "//" + ], + [ + "0 ", + ": " + ], + [ + "= _", + "totalSupply" + ], + [ + "(\\n address from,\\n address to,\\n uint256 ", + "startTokenId" + ], + [ + "previous", + "AdminRole" + ], + [ + ";\\n emit ", + "ApprovalForAll" + ], + [ + "prevent", + "s " + ], + [ + "verifyCallResult", + "FromTarget" + ], + [ + "14", + "6" + ], + [ + "Counter ", + "overflow is " + ], + [ + "rele", + "ased" + ], + [ + "keccak256(abi.encode", + "(" + ], + [ + "ident", + "ifier" + ], + [ + "track", + "ing " + ], + [ + "would ", + "have " + ], + [ + "ateg", + "y " + ], + [ + "_balances[sender", + "] = " + ], + [ + "HASHED", + "_NAM" + ], + [ + "HASHED", + "_VERSION" + ], + [ + "keep ", + "fees at " + ], + [ + " > 0) {\\n ", + "// The easiest way to bubble the revert reason is using memory via assembly" + ], + [ + "compliant ", + "contract" + ], + [ + "TokenOwnership memory ", + "ownership" + ], + [ + "che", + "ap" + ], + [ + "\"// SPDX-License-Identifier: GPL-3.0-or-later\\n// This program is free software: you can redistribute it and/or modify\\n// it under the terms of the GNU General Public License as published by\\n// the Free Software Foundation, either version 3 of the License, or\\n// (at your option) any later version.\\n\\n// This program is distributed in the hope that it will be useful,\\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\n// GNU General Public License for more details.\\n\\n// You should have received a copy of the GNU General Public License\\n// along with this program. If not, see .", + "\\n\\npragma solidity ^0.7.0" + ], + [ + "autoLiquidity", + "Receiver" + ], + [ + "\\n // Look for revert reason and bubble it up if present\\n if (returndata.length", + " > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly" + ], + [ + "zeppelin.solution", + "s/" + ], + [ + ")", + ") == " + ], + [ + "D", + "F" + ], + [ + "in ", + "child " + ], + [ + "log", + "(uint256 " + ], + [ + "Int", + "eres" + ], + [ + ") internal pure returns (", + "bytes memory) {\\n if (success) {\\n return returndata;\\n } else {" + ], + [ + "s that ", + "are " + ], + [ + "15", + "2" + ], + [ + "royalty", + "Info" + ], + [ + "An", + "y " + ], + [ + "previous ", + "owner of the given token ID" + ], + [ + "implementation ", + "- " + ], + [ + "upp", + "er" + ], + [ + "This is ", + "equivalent to " + ], + [ + ");\\n }\\n }\\n\\n function ", + "_" + ], + [ + ",address ", + "verifyingContract" + ], + [ + "limit ", + "of " + ], + [ + "Dis", + "abled" + ], + [ + "fromBalance ", + "- amount" + ], + [ + ") {\\n revert(\\\"", + "ECDSA: invalid signature " + ], + [ + "address representing the ", + "previous owner of the given token ID" + ], + [ + "verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ", + ") internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {" + ], + [ + "(", + "operator" + ], + [ + ".", + "io/" + ], + [ + "F", + "ac" + ], + [ + "L", + "imit " + ], + [ + ", ", + "signature" + ], + [ + "token", + "From" + ], + [ + "is ", + "impossible " + ], + [ + "er ", + "is " + ], + [ + "st", + "age " + ], + [ + "Co", + "ordin" + ], + [ + "\\n ", + "if (" + ], + [ + "set", + ", the " + ], + [ + "sender", + "'s balance " + ], + [ + " of the ", + "sender's balance " + ], + [ + "Tim", + "elock" + ], + [ + "--------", + "----" + ], + [ + "start", + "s " + ], + [ + "`tokenId` ", + "from `from` to `to`" + ], + [ + "_token", + "Transfer" + ], + [ + ".\\r\\n *", + "/" + ], + [ + ";\\r\\n }\\r\\n", + "\\r\\n /**\\r\\n * @dev Returns the " + ], + [ + "ownership ", + "above " + ], + [ + "because ", + "we check " + ], + [ + "br", + "anc" + ], + [ + "'s balance ", + "can't " + ], + [ + "if (b", + " == 0" + ], + [ + "whenever possible", + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this " + ], + [ + "].sub(amount, \\\"ERC20: ", + "transfer " + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5", + ".0) (" + ], + [ + ".\\n *\\n * _Available since v4.3._\\n */\\n function ", + "verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {" + ], + [ + "MINIMUM", + "_LIQUIDITY" + ], + [ + "_init_unchain", + "ed(" + ], + [ + "using the provided one", + ".\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {" + ], + [ + "happ", + "en" + ], + [ + "] = approved", + ";\\n emit ApprovalForAll" + ], + [ + "Underflow", + " of the sender's balance " + ], + [ + "Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165", + " is IERC165 {\\n /**\\n * @dev " + ], + [ + "and the recipient", + "'s balance can't " + ], + [ + "gorith", + "m" + ], + [ + "(\\n address from,\\n address to,\\n uint256 startTokenId", + ",\\n uint256 quantity\\n " + ], + [ + "tokenFrom", + "Reflection" + ], + [ + "is impossible ", + "because we check " + ], + [ + "ownership above ", + "and the recipient's balance can't " + ], + [ + "Underflow of the sender's balance ", + "is impossible because we check " + ], + [ + "ownership above and the recipient's balance can't ", + "realistically overflow" + ], + [ + "(", + "IERC20 token" + ], + [ + "4", + ".0" + ], + [ + "A", + "b" + ], + [ + "c", + "vx" + ], + [ + "g", + "t(" + ], + [ + "s", + "em" + ], + [ + "v", + "ex" + ], + [ + "ad", + "apter" + ], + [ + ", ", + "(" + ], + [ + "\\n * ", + "uses an " + ], + [ + "function ", + "selector" + ], + [ + "cont", + "in" + ], + [ + "Token", + "Approval" + ], + [ + "returns (", + "uint256 " + ], + [ + "from ", + "address representing the previous owner of the given token ID" + ], + [ + "Sender", + "ApprovedOrOwner" + ], + [ + ", uint256 ", + "p1" + ], + [ + "Of", + "(uint256 tokenId" + ], + [ + "The ", + "approval is cleared when the token is " + ], + [ + "This ", + "will " + ], + [ + ", p", + "ath" + ], + [ + "\\n // ", + "The " + ], + [ + "] = ", + "bytes1(uint8(" + ], + [ + "Out", + "Min" + ], + [ + "rou", + "nd " + ], + [ + "has ", + "a " + ], + [ + ";\\n }\\n\\n ", + "/**\\n * Returns the " + ], + [ + "address,", + "uint," + ], + [ + "Deleg", + "ates" + ], + [ + "And", + "Address" + ], + [ + "p0", + ", uint256 p1" + ], + [ + "Slot", + "AndAddress" + ], + [ + "doc", + "s." + ], + [ + "_maxTxAmount", + ".\"" + ], + [ + "(_msgSender(), ", + "recipient, amount" + ], + [ + "swa", + "pping " + ], + [ + "48", + " + " + ], + [ + "comput", + "e " + ], + [ + "quantity ", + "== 1" + ], + [ + "produc", + "t " + ], + [ + "tokenIds", + "Idx" + ], + [ + "correct", + "ness " + ], + [ + "Merkle", + "Root" + ], + [ + "a\\n * `", + "revert` opcode (which leaves remaining gas untouched) while Solidity" + ], + [ + "Author", + "izer" + ], + [ + "cach", + "e" + ], + [ + "EEEE", + "EEEE" + ], + [ + "\\n mapping(uint256 => ", + "address) private " + ], + [ + "(string ", + "name" + ], + [ + " bits\\n *\\n * _Available since v4.7._\\n */\\n function ", + "toUint" + ], + [ + "\"Exceeds the ", + "maxWalletSize" + ], + [ + "O(1", + ") " + ], + [ + ").interfaceId", + ";\\n }\\n}\\n\"" + ], + [ + "is already ", + "open" + ], + [ + "Uti", + "l" + ], + [ + "FAC", + "E_" + ], + [ + "smar", + "t" + ], + [ + "overridden", + ";" + ], + [ + "within ", + "bound" + ], + [ + "/` operator. Note: this function uses ", + "a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity" + ], + [ + "_allowances[sender", + "][_msgSender()" + ], + [ + "_isApprovedOrOwner(_msgSender(), tokenId", + "), \\\"ERC721: " + ], + [ + "EIP712Domain", + "(string name" + ], + [ + "low level call was successful, and revert if it was", + "n't" + ], + [ + "Counter overflow is ", + "incredibly unrealis" + ], + [ + "implementation - ", + "MIT licen" + ], + [ + "Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165 is IERC165 {\\n /**\\n * @dev ", + "See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165" + ], + [ + "The approval is cleared when the token is ", + "burned" + ], + [ + "\"Exceeds the maxWalletSize", + ".\"" + ], + [ + "/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity", + "\\n * uses an " + ], + [ + "(", + "bytes32 _" + ], + [ + "]", + ";\\n }\\n\\n function " + ], + [ + "g", + "s" + ], + [ + "i", + "tion" + ], + [ + "k", + "Last" + ], + [ + "─", + "─" + ], + [ + "▄", + "▄" + ], + [ + "\\n", + "@notice " + ], + [ + "re", + "tr" + ], + [ + "in", + "\\n * " + ], + [ + "ex", + "pos" + ], + [ + "To", + "Add" + ], + [ + ".\\n *\\n * ", + "Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll" + ], + [ + "in ", + "an " + ], + [ + ". ", + "Note that " + ], + [ + "and ", + "it is " + ], + [ + "new", + "MarketingWallet" + ], + [ + "string ", + "calldata " + ], + [ + "nam", + "e " + ], + [ + "operator", + "Approval" + ], + [ + " ", + " " + ], + [ + "for", + "ce" + ], + [ + "old", + "Value" + ], + [ + "arke", + "t " + ], + [ + ");\\n\\n /**\\n * @dev ", + "Revert " + ], + [ + "dig", + "est " + ], + [ + "onERC721Received", + "(\\n address operator,\\n address from" + ], + [ + "exists", + ".\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll" + ], + [ + "}.\\n *\\n * ", + "Tokens start existing when they are " + ], + [ + ",\\n bytes memory data", + "\\n " + ], + [ + "//////////////", + "/" + ], + [ + "infinite ", + "allowance" + ], + [ + "byte", + "code " + ], + [ + ";\\n }\\n if (", + "p < " + ], + [ + "IERC165.sol\\\";\\n\\n/**\\n * @dev ", + "Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165 is IERC165 {\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165" + ], + [ + "nextTokenId = ", + "tokenId + " + ], + [ + "Returns whether `tokenId` ", + "exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll" + ], + [ + "hasRole(role, account", + ")) {\\n " + ], + [ + "low level call was successful, and revert if it wasn't", + ", either by bubbling the\\n * revert reason " + ], + [ + "IERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165 is IERC165 {\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165", + ").interfaceId;\\n }\\n}\\n\"" + ], + [ + "Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll", + "}.\\n *\\n * Tokens start existing when they are " + ], + [ + " ", + "value" + ], + [ + "\"", + "SafeCast: value doesn't fit in " + ], + [ + ")", + "{\\n " + ], + [ + "M", + "ight " + ], + [ + "[", + "ERC721" + ], + [ + "al", + "p" + ], + [ + ", ", + "to" + ], + [ + ");", + "\\n\\n" + ], + [ + "a ", + "< " + ], + [ + "Token", + "Out" + ], + [ + "er ", + "the " + ], + [ + "lo", + "se " + ], + [ + " = ", + "4" + ], + [ + "approve", + ".selector, " + ], + [ + "token ", + "has been " + ], + [ + "token ", + "will be the " + ], + [ + "12", + "7" + ], + [ + "and", + "\\n * {" + ], + [ + "_msgSender(", + "))" + ], + [ + "If ", + "set, the " + ], + [ + "which ", + "the " + ], + [ + "approved", + "Address " + ], + [ + "` and ", + "the `" + ], + [ + ";\\n\\nimport \\\"", + "../../" + ], + [ + "baseURI", + "` and the `" + ], + [ + "try", + "Div" + ], + [ + "given ", + "address" + ], + [ + "();\\n ", + "}\\n\\n " + ], + [ + "currentAllowance ", + "!= type(uint256).max" + ], + [ + "royalty ", + "payment" + ], + [ + "] = true", + ";\\n " + ], + [ + "Payment", + "Splitter" + ], + [ + ".\\n *\\n * See {", + "ERC20-_burn" + ], + [ + "mstore(0x", + "00" + ], + [ + "chainId", + ",address verifyingContract" + ], + [ + "URI for ", + "each" + ], + [ + "/= 10", + ";\\n }\\n " + ], + [ + "_TOKEN", + "S" + ], + [ + " of the `", + "baseURI` and the `" + ], + [ + "\"Exceeds the ", + "_maxTxAmount.\"" + ], + [ + ".\\n * ", + "Note that " + ], + [ + "setFeeTo", + "Setter" + ], + [ + "Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner(", + ") {\\n require(" + ], + [ + "Primary", + "Sales" + ], + [ + "allPairs", + "Length" + ], + [ + "Short", + "String" + ], + [ + "interface ID", + " for " + ], + [ + "valu", + "es[" + ], + [ + "resulting ", + "URI for each" + ], + [ + "concatenation", + " of the `baseURI` and the `" + ], + [ + "address spender", + " = _msgSender(" + ], + [ + "Base URI for computing {tokenURI}. ", + "If set, the " + ], + [ + "onERC721Received(\\n address operator,\\n address from", + ",\\n uint256 tokenId" + ], + [ + "token will be the ", + "concatenation of the `baseURI` and the `" + ], + [ + "Base URI for computing {tokenURI}. If set, the ", + "resulting URI for each" + ], + [ + "token will be the concatenation of the `baseURI` and the `", + "tokenId" + ], + [ + "B", + "AS" + ], + [ + "N", + "ext" + ], + [ + "_", + "swapTokensAtAmount" + ], + [ + "c", + "9" + ], + [ + "n", + "ess" + ], + [ + "tu", + "ck" + ], + [ + "Co", + "re" + ], + [ + "must ", + "not be " + ], + [ + "Mint", + "ing" + ], + [ + "s[", + "0" + ], + [ + "returns (bool", + ")\\n {\\n " + ], + [ + "transferFrom", + "`" + ], + [ + "ID", + "EX" + ], + [ + "if the ", + "current " + ], + [ + "we ", + "can " + ], + [ + "vari", + "able" + ], + [ + "s = ", + "0" + ], + [ + "IC", + "AL" + ], + [ + "_get", + "Current" + ], + [ + "bit ", + "in packed " + ], + [ + "}.\\n *\\n * ", + "Counterpart to Solidity's `" + ], + [ + "pow", + "er" + ], + [ + "Revok", + "ed(" + ], + [ + "\\\"\\n ", + ");\\n " + ], + [ + "Standard", + "Token" + ], + [ + "End", + "point" + ], + [ + "ERC165 ", + "interface ID for " + ], + [ + "utils/introspection/ERC165", + ".sol\"" + ], + [ + "utils/Context.sol\\\";\\n\\n/**\\n * @dev ", + "Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum." + ], + [ + ".\\n *\\n * The ", + "`" + ], + [ + "token/ERC20/extensions/IERC20Metadata", + ".sol\"" + ], + [ + ".\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value", + "\\n " + ], + [ + "Det", + "ailed" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9", + ".0) (" + ], + [ + "if (!_exists(tokenId", + ")) revert " + ], + [ + "\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage", + ");\\n }\\n }\\n }\\n}\\n\"" + ], + [ + ") {\\n require(isContract(target), \\\"Address: ", + "static " + ], + [ + "maintain ", + "correctness " + ], + [ + "sender is not ", + "the owner" + ], + [ + "onERC721Received(\\n address operator,\\n address from,\\n uint256 tokenId", + ",\\n bytes calldata data\\n ) external returns (bytes4" + ], + [ + "(", + "proof" + ], + [ + ".", + "mul" + ], + [ + "0", + "8" + ], + [ + "<", + " b" + ], + [ + "[", + "id" + ], + [ + "a", + ", " + ], + [ + "{", + "\\\"" + ], + [ + "\\n ", + "{\\n " + ], + [ + "it", + ", " + ], + [ + "address ", + "or " + ], + [ + ");\\n ", + "} else {\\n " + ], + [ + " to ", + "`recipient" + ], + [ + "be", + "com" + ], + [ + "this", + "." + ], + [ + "The ", + "`" + ], + [ + "name", + "\\n " + ], + [ + "symbol", + "\\n " + ], + [ + "liquidity", + "Pair" + ], + [ + ".\\n ", + "//\\n // " + ], + [ + "last ", + "token" + ], + [ + "\\\");\\n require(", + "isContract(target), \\\"Address: " + ], + [ + "88", + "8" + ], + [ + "DE", + "LEG" + ], + [ + "does not ", + "provide " + ], + [ + "LO", + "CK" + ], + [ + "quantity ", + "> " + ], + [ + "per ", + "block " + ], + [ + "ary ", + "data " + ], + [ + "(\\r\\n ", + "uint256 " + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist", + ".\\n *\\n * Emits a {Transfer} event.\\n */\\n function _" + ], + [ + " to `to", + "`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function " + ], + [ + "utils/introspection/ERC165", + ".sol\\\";\\n\\n/**\\n * @dev " + ], + [ + "Contract modul", + "e that " + ], + [ + "mapping(address => bool", + ")) private _operatorApprovals" + ], + [ + ") internal view returns (uint256) {\\n return ", + "_" + ], + [ + "bytes memory buffer = new bytes(", + "digits" + ], + [ + "IERC721Receiver(to).", + "onERC721Received" + ], + [ + "`.\\n * ", + "The approval is cleared when the token is burned" + ], + [ + "stat", + "ement" + ], + [ + "s `tokenId", + "`.\\n * The approval is cleared when the token is burned" + ], + [ + "call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`", + ".\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n " + ], + [ + "for\\n // ", + "ownership above and the recipient's balance can't realistically overflow" + ], + [ + "owner to operator ", + "approval" + ], + [ + "Underflow of the sender's balance is impossible because we check ", + "for\\n // ownership above and the recipient's balance can't realistically overflow" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _", + "burn(uint256 tokenId" + ], + [ + "(", + "b" + ], + [ + "(", + "https://" + ], + [ + "(", + "\\r\\n " + ], + [ + "4", + "1" + ], + [ + "6", + "ee" + ], + [ + "D", + "5" + ], + [ + "K", + "O" + ], + [ + "U", + "nt" + ], + [ + "_", + "excludeFromMaxTransaction" + ], + [ + "uint256", + ") {" + ], + [ + "end", + " of the " + ], + [ + "uint256 ", + "fromBalance = " + ], + [ + "el", + "d " + ], + [ + "el", + "se if (" + ], + [ + "index", + " < " + ], + [ + "li", + "pp" + ], + [ + ";\\n", + "}\\n\\n" + ], + [ + "'s ", + "index" + ], + [ + "`to", + "`." + ], + [ + "tax", + "Fee" + ], + [ + "_mint", + "ERC2309" + ], + [ + "address,", + "bool" + ], + [ + ");\\n }\\n\\n /**\\n * @dev S", + "afely mint" + ], + [ + ";\\r\\n ", + "uint256 " + ], + [ + "`. ", + "Empty" + ], + [ + "already ", + "minted" + ], + [ + "mak", + "es " + ], + [ + "\"evm", + "Version" + ], + [ + "_F", + "E" + ], + [ + ".sol\\\";\\nimport \\\"../../", + "utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum." + ], + [ + "() internal view virtual returns (", + "string memory) {\\n return " + ], + [ + ",uint256 ", + "chainId,address verifyingContract" + ], + [ + "\"@openzeppelin/contracts/utils/", + "Address.sol\"" + ], + [ + "emits ", + "an " + ], + [ + "liqui", + "dation" + ], + [ + "compu", + "te" + ], + [ + "revok", + "e " + ], + [ + "b0", + "6" + ], + [ + "Non-Fungible Token Standard", + ", includ" + ], + [ + "] = to", + ";\\n\\n emit Transfer" + ], + [ + "0.4.", + "25" + ], + [ + "62", + "39" + ], + [ + "TransferFromIncorrect", + "Owner" + ], + [ + "token will be the concatenation of the `baseURI` and the `tokenId", + "`. Empty" + ], + [ + "Unt", + "il" + ], + [ + "\"evmVersion", + "\"" + ], + [ + " ", + "if " + ], + [ + "(", + ");\\n _" + ], + [ + "6", + "7" + ], + [ + "E", + "7" + ], + [ + "E", + "l" + ], + [ + "i", + " = 0; i" + ], + [ + "y", + "ield" + ], + [ + "\\n", + "contract " + ], + [ + "rom", + "is" + ], + [ + "lo", + "an " + ], + [ + "] ", + "== 0) {\\n " + ], + [ + "this ", + "extension" + ], + [ + "balanceOf", + "(to" + ], + [ + "\\\");\\n ", + "} else if (error == RecoverError.InvalidSignature" + ], + [ + "\\n */\\n function ", + "_" + ], + [ + "If ", + "you " + ], + [ + "_balances[", + "owner" + ], + [ + "At", + "(uint256 index" + ], + [ + ";\\r\\n", + " " + ], + [ + ") public view virtual override returns (", + "uint256) {\\n require(" + ], + [ + "multi", + "proof" + ], + [ + "ERC721: ", + "transfer to non ERC721Receiver implementer" + ], + [ + "Percent", + "age " + ], + [ + "receive", + "() external payable " + ], + [ + "ea", + "rn" + ], + [ + "Only ", + "one " + ], + [ + "keccak256(abi.encode", + "Packed(" + ], + [ + "If `to` refers to a smart contract, it must ", + "implement" + ], + [ + "_startTokenId", + "()" + ], + [ + ";\\n\\n // Mapping from ", + "owner to operator approval" + ], + [ + ";\\n }", + "\\n " + ], + [ + "_LI", + "MIT" + ], + [ + "minimum", + " " + ], + [ + ";\\n\\n // Mapping from token ID to ", + "approved address" + ], + [ + "accounts that ", + "have " + ], + [ + "Voting", + "Power" + ], + [ + "data structu", + "res" + ], + [ + "price0", + "CumulativeLast" + ], + [ + "price1", + "CumulativeLast" + ], + [ + "downcasted = ", + "int" + ], + [ + "tracking ", + "data structures" + ], + [ + "] = bytes1(uint8(", + "48 + " + ], + [ + " to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function ", + "transfer(address to, uint256 amount" + ], + [ + " ", + "memory " + ], + [ + "\"", + "trading " + ], + [ + ".", + "\\n /// " + ], + [ + "S", + "te" + ], + [ + "U", + "T" + ], + [ + "b", + "il" + ], + [ + "t", + "ree" + ], + [ + "th", + "ough " + ], + [ + "de", + "crease" + ], + [ + ");\\n ", + "} else if (" + ], + [ + "if ", + "iszero(" + ], + [ + "data", + "." + ], + [ + "new", + "AdminRole" + ], + [ + "value ", + "to " + ], + [ + "IERC721", + " {\\n /**\\n * @dev Returns the " + ], + [ + "_transfer", + "Standard" + ], + [ + "{\\n ", + " " + ], + [ + "prod", + "0, " + ], + [ + "Buy", + "Fees" + ], + [ + "\"@openzeppelin/contracts/", + "utils/introspection/IERC165.sol\"" + ], + [ + "uint256) {\\n ", + "if (" + ], + [ + "_burn", + "(tokenId, " + ], + [ + ");\\n }\\n\\n ", + "/// @dev " + ], + [ + "onlyOwner ", + "{\\r\\n " + ], + [ + "////////////////////////////////", + "///////////////" + ], + [ + "\\n ", + "* " + ], + [ + "this function ", + "is\\n * " + ], + [ + ") external returns (bool", + ");\\n function " + ], + [ + "https://github.com/", + "oraclize" + ], + [ + "projectId", + "To" + ], + [ + "refer", + "rer" + ], + [ + "permis", + "sion " + ], + [ + "max ", + "value of " + ], + [ + "See ", + "https://" + ], + [ + "Pre", + "fix" + ], + [ + "loc", + "al" + ], + [ + "Owner(", + ");\\n _" + ], + [ + "API", + "_" + ], + [ + "token id", + "s " + ], + [ + " of the `", + "nextInitialized` " + ], + [ + ";\\n\\ninterface ", + "I" + ], + [ + "42", + "146" + ], + [ + "tak", + "es " + ], + [ + "UB", + "LIC" + ], + [ + ";\\n\\n // Token ", + "symbol\\n " + ], + [ + "oraclize", + "API_" + ], + [ + "CR", + "IP" + ], + [ + "futu", + "re" + ], + [ + "_removeTokenFrom", + "OwnerEnumeration" + ], + [ + "api/", + "blob/" + ], + [ + "spendAllowance(", + "from, " + ], + [ + "Throws if the ", + "sender is not the owner" + ], + [ + "5` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless ", + "this function is\\n * " + ], + [ + "The default value of {decimals} is 18. To ", + "select a different value for" + ], + [ + "secp256k", + "1" + ], + [ + "-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall", + "(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n " + ], + [ + "_approve(sender", + ", _msgSender(), " + ], + [ + "_balances[from] = ", + "fromBalance - amount" + ], + [ + "/ethereum-", + "api/blob/" + ], + [ + "compliant contract", + ".\\n */\\ninterface " + ], + [ + "per block ", + "allowed" + ], + [ + "https://github.com/oraclize", + "/ethereum-api/blob/" + ], + [ + "C", + "app" + ], + [ + "b", + "42146" + ], + [ + "o", + "d" + ], + [ + "o", + "re" + ], + [ + "s", + "load" + ], + [ + "re", + "ject" + ], + [ + "ti", + "vel" + ], + [ + ", ", + "to " + ], + [ + ");", + "\\r\\n " + ], + [ + "is", + "Bot" + ], + [ + "vi", + "leg" + ], + [ + "is ", + "trigge" + ], + [ + ": ", + "URI " + ], + [ + "be ", + "the " + ], + [ + "tokenId", + ".toString" + ], + [ + "bu", + "cket" + ], + [ + ", uint256 ", + "p2" + ], + [ + "(uint256 ", + "_tokenId" + ], + [ + ".sol\\\"", + ";\\r\\n\\r\\n" + ], + [ + "of the ", + "product" + ], + [ + "block", + "Num" + ], + [ + "_transfer", + "(owner, " + ], + [ + "tokens", + ".\\n */\\n function " + ], + [ + "Id ", + "= " + ], + [ + "Returns ", + "`" + ], + [ + "recei", + "v" + ], + [ + "24", + "6239" + ], + [ + "Con", + "sum" + ], + [ + ".\\n ", + "uint256 " + ], + [ + ", address indexed ", + "sender" + ], + [ + ");\\r\\n ", + "return true" + ], + [ + "88", + "46c" + ], + [ + "also ", + "called " + ], + [ + "36", + "0e" + ], + [ + "enti", + "ally " + ], + [ + "digits", + ";\\n while (temp != 0) {\\n " + ], + [ + "digits", + "++;\\n temp " + ], + [ + "\\n * {", + "decimals} " + ], + [ + "Orac", + "lize" + ], + [ + "p0, address p1", + ", address p2" + ], + [ + "p0, address p1", + ", string memory p2" + ], + [ + "p0, address p1", + ", bool p2" + ], + [ + "p0, bool p1", + ", address p2" + ], + [ + "p0, bool p1", + ", string memory p2" + ], + [ + "p0, bool p1", + ", bool p2" + ], + [ + "p0, string memory p1", + ", address p2" + ], + [ + "p0, string memory p1", + ", string memory p2" + ], + [ + "p0, string memory p1", + ", bool p2" + ], + [ + "3c", + "7d" + ], + [ + "\\\"0", + "\\\";\\n }\\n uint256 temp = value;\\n uint256 " + ], + [ + "srcRep", + "Num" + ], + [ + "⠀⠀⠀⠀", + "⠀⠀⠀⠀" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Destroy", + "s `tokenId`.\\n * The approval is cleared when the token is burned" + ], + [ + "at a ", + "given " + ], + [ + "string private _name", + ";\\n\\n // Token symbol\\n " + ], + [ + "xx", + "x" + ], + [ + ";\\n }\\n return ", + "string(buffer" + ], + [ + ";\\n\\n // Token ", + "name\\n " + ], + [ + "if (value == 0) {\\n return ", + "\\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 " + ], + [ + "destin", + "ation" + ], + [ + "fac", + "ilit" + ], + [ + "e9", + "360e" + ], + [ + "Inspired by ", + "Oraclize" + ], + [ + "address(0) ", + "&& " + ], + [ + "sstore", + "(" + ], + [ + "dou", + "bl" + ], + [ + ".sol\\\";\\nimport \\\"./extensions/", + "IERC20Metadata" + ], + [ + "owner != address(0), \\\"", + "ERC721: " + ], + [ + "198", + "246239" + ], + [ + "`from` to `to` ", + "using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom" + ], + [ + "135", + "8846c" + ], + [ + "you should overload it", + ".\\n *\\n * " + ], + [ + "8/", + "oraclizeAPI_" + ], + [ + "would have ", + "to be " + ], + [ + "FACE_", + "ID" + ], + [ + "/= 10;\\n }\\n ", + "bytes memory buffer = new bytes(digits" + ], + [ + "call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ", + ") internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call" + ], + [ + "6ee", + "1358846c" + ], + [ + "uint256 fromBalance = ", + "_balances[from" + ], + [ + "b06", + "3c7d" + ], + [ + "0.4.25", + ".sol" + ], + [ + "https://github.com/oraclize/ethereum-api/blob/", + "b42146" + ], + [ + "digits;\\n while (temp != 0) {\\n ", + "digits++;\\n temp " + ], + [ + "\\n * {decimals} ", + "you should overload it.\\n *\\n * " + ], + [ + "string private _name;\\n\\n // Token symbol\\n ", + "string private _symbol" + ], + [ + "if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 ", + "digits;\\n while (temp != 0) {\\n digits++;\\n temp " + ], + [ + "e9360e", + "8/oraclizeAPI_" + ], + [ + "Inspired by Oraclize", + "API" + ], + [ + "198246239", + "e9360e8/oraclizeAPI_" + ], + [ + "6ee1358846c", + "198246239e9360e8/oraclizeAPI_" + ], + [ + "b063c7d", + "6ee1358846c198246239e9360e8/oraclizeAPI_" + ], + [ + "https://github.com/oraclize/ethereum-api/blob/b42146", + "b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_" + ], + [ + "if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp ", + "/= 10;\\n }\\n bytes memory buffer = new bytes(digits" + ], + [ + "https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_", + "0.4.25.sol" + ], + [ + "7", + "f" + ], + [ + "G", + "obbl" + ], + [ + "O", + " " + ], + [ + "}", + ".\\n *\\n * Requirements:\\n *\\n * - `" + ], + [ + "\\n", + "\\n // " + ], + [ + ", ", + "`" + ], + [ + "token", + "\\n * " + ], + [ + "\\n * ", + "of " + ], + [ + "Cont", + "ent" + ], + [ + "address(", + "uniswapV2Router" + ], + [ + "Of", + "f" + ], + [ + "IERC20", + ".sol\\\";\\nimport \\\"./extensions/IERC20Metadata" + ], + [ + "s.", + "\\n " + ], + [ + "Balanc", + "er" + ], + [ + ") internal pure returns (", + "bytes32" + ], + [ + "have ", + "the " + ], + [ + "(_", + "packedAddressData[owner" + ], + [ + "` and ", + "a `" + ], + [ + "storage ", + "to " + ], + [ + " - ", + "1 (" + ], + [ + "oc", + "cur" + ], + [ + "tic ", + "as " + ], + [ + ")\\n ", + "}\\n\\n // " + ], + [ + ";\\r\\n ", + "require(" + ], + [ + " := ", + "div(" + ], + [ + "Round", + "ing" + ], + [ + "auto", + "Burn" + ], + [ + "Upgradeable", + ".sol\"" + ], + [ + "target ", + "address " + ], + [ + "New", + "ton" + ], + [ + "% ", + "10))" + ], + [ + "allowance(", + "address(this), " + ], + [ + "nCheckpoint", + "s " + ], + [ + "_ownedTokens", + "Index" + ], + [ + "startTokenId ", + "+ " + ], + [ + "Distribu", + "tor" + ], + [ + "compl", + "et" + ], + [ + "contracts", + ".\\n */\\n function _baseURI" + ], + [ + "proofFlag", + "s" + ], + [ + "_tokenApprovals", + ";\\n\\n // Mapping from owner to operator approval" + ], + [ + "underflow", + " is " + ], + [ + "sk", + "im" + ], + [ + "BITMASK_ADDRESS_DATA_ENTRY", + ";\\n }\\n\\n /**\\n * Returns the " + ], + [ + "eff", + "ec" + ], + [ + ") public payable virtual ", + "override {\\n " + ], + [ + "safeIn", + "creaseAllowance" + ], + [ + "safeDecrease", + "Allowance" + ], + [ + "zeppelin.solutions/", + "t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general " + ], + [ + "in child ", + "contracts.\\n */\\n function _baseURI" + ], + [ + "Counter overflow is incredibly unrealis", + "tic as " + ], + [ + "token has been ", + "burned" + ], + [ + ";\\n\\n // Token name\\n ", + "string private _name;\\n\\n // Token symbol\\n string private _symbol" + ], + [ + "IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata", + ".sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum." + ], + [ + "(_packedAddressData[owner", + "] " + ], + [ + " - 1 (", + "max value of " + ], + [ + ".", + "l" + ], + [ + ";", + "\\n " + ], + [ + "A", + "rt" + ], + [ + "_", + "erc20" + ], + [ + "s", + ": " + ], + [ + "v", + "ing" + ], + [ + "in", + "it" + ], + [ + "\\n *", + " " + ], + [ + "of ", + "denominator" + ], + [ + "\\n * ", + "- " + ], + [ + "value ", + "% 10))" + ], + [ + "with ", + "full " + ], + [ + ");\\n }\\n\\n /**\\n * @dev ", + "Mint" + ], + [ + "pa", + "per" + ], + [ + "`amount", + "` is the " + ], + [ + "Un", + "paused" + ], + [ + "verif", + "ication " + ], + [ + "_check", + "Owner" + ], + [ + ") {\\n // ", + "Inspired by OraclizeAPI" + ], + [ + "''", + "''" + ], + [ + "digits", + "] = bytes1(uint8(48 + " + ], + [ + "Metadata ", + "extension" + ], + [ + "while (", + "value " + ], + [ + "prod1", + " * " + ], + [ + "denominator * ", + "inv" + ], + [ + "buffer[", + "digits] = bytes1(uint8(48 + " + ], + [ + "twos", + "), " + ], + [ + "` is zero, `tokenId` ", + "has been " + ], + [ + "prod1 ", + ":= sub(" + ], + [ + "pragma solidity ^0.8.0", + ";\\r\\n\\r\\n" + ], + [ + "prod0 ", + ":= " + ], + [ + "CO", + "MM" + ], + [ + "256 ", + "division" + ], + [ + "512", + " bit " + ], + [ + "mm", + ", prod0" + ], + [ + "\\n\\n ", + "if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits" + ], + [ + "in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account", + " to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount" + ], + [ + "256 bits ", + "of the product" + ], + [ + "_burnCounter ", + "cannot be " + ], + [ + "Emits a {Transfer", + "} event" + ], + [ + "ce\\n // ", + "https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol" + ], + [ + "significant ", + "256 bits of the product" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n ", + "(bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall" + ], + [ + "And ", + "also called " + ], + [ + "(uint256 value) internal pure returns (string memory", + ") {\\n // Inspired by OraclizeAPI" + ], + [ + "implementation - MIT licen", + "ce\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol" + ], + [ + "with full ", + "precision" + ], + [ + "denominator * inv", + " = 1 " + ], + [ + "=", + "\\\"" + ], + [ + "T", + "w" + ], + [ + "U", + "S" + ], + [ + "e", + "ed" + ], + [ + "x", + "i" + ], + [ + "\\n ", + ") " + ], + [ + "address", + "[] memory" + ], + [ + "end", + "ed to " + ], + [ + "amount", + ";\\n\\n emit Transfer" + ], + [ + "ing ", + "one " + ], + [ + "byt", + "e(" + ], + [ + "st", + "ax" + ], + [ + "af", + "t " + ], + [ + "), ", + "0x" + ], + [ + "if (", + "nextTokenId " + ], + [ + "/ ", + "/" + ], + [ + "pr", + "incipal" + ], + [ + "length", + " = " + ], + [ + ");\\n\\n ", + "emit " + ], + [ + ".sol\\\"", + ";\\n\\n/**" + ], + [ + "_transfer", + "Tokens" + ], + [ + "allowance ", + "is not " + ], + [ + "constructor", + "(address " + ], + [ + ":= ", + "and" + ], + [ + ");\\n }\\n\\n ", + "/**\\n * " + ], + [ + "unchecked {\\n ", + "uint256 " + ], + [ + "\\n *\\n * ", + "Emits " + ], + [ + "signature ", + "from " + ], + [ + ") internal virtual {\\n ", + "_" + ], + [ + "ST", + "OR" + ], + [ + "packed ", + "ownership " + ], + [ + "less than ", + "2^256" + ], + [ + "toHexString", + "(uint256(" + ], + [ + "uint256(", + "value % 10))" + ], + [ + "Counter ", + "underflow is " + ], + [ + "distribu", + "tion" + ], + [ + ");\\n uint256 ", + "c = " + ], + [ + "fees ", + "* " + ], + [ + "paramet", + "er" + ], + [ + "blacklist", + "ed" + ], + [ + "too ", + "long" + ], + [ + "`sender` to `recipient", + "` " + ], + [ + "_approve(owner, spender, currentAllowance ", + "- amount" + ], + [ + "\"Address: insufficient ", + "balance\"" + ], + [ + "Reveal", + "ed" + ], + [ + ") external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from ", + "`from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom" + ], + [ + "This is equivalent to ", + "`" + ], + [ + "overridden;", + "\\n *\\n * NOTE: This " + ], + [ + "spendAllowance(from, ", + "spender, amount" + ], + [ + "5` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * ", + "overridden;\\n *\\n * NOTE: This " + ], + [ + "_transfer(owner, ", + "to, amount" + ], + [ + "would have to be ", + "2**256" + ], + [ + "in child contracts.\\n */\\n function _baseURI", + "() internal view virtual returns (string memory) {\\n return " + ], + [ + "buffer[digits] = bytes1(uint8(48 + ", + "uint256(value % 10))" + ], + [ + "in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount", + ") external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom" + ], + [ + "implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol", + "\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits" + ], + [ + "Counter underflow is ", + "impossible " + ], + [ + ")", + ")." + ], + [ + ".", + "amount" + ], + [ + "<", + "< " + ], + [ + "W", + "ait" + ], + [ + "_", + "M" + ], + [ + "_", + "operations" + ], + [ + "`", + "spender" + ], + [ + "b", + "8" + ], + [ + "to", + ".code.length" + ], + [ + ") ", + "+ (" + ], + [ + "co", + "in" + ], + [ + "is ", + "point" + ], + [ + "as", + "tic" + ], + [ + "si", + "l" + ], + [ + "require(", + "!" + ], + [ + "sender", + "Balance " + ], + [ + "contract ", + "to " + ], + [ + "max", + "TX" + ], + [ + "The ", + "address to " + ], + [ + ", address ", + "tokenB" + ], + [ + "`.", + "\\n " + ], + [ + "`.", + "\\r\\n */\\r\\n function " + ], + [ + "ON", + "ICAL" + ], + [ + ".\\n * ", + "To " + ], + [ + "transfer ", + "from " + ], + [ + "__", + "_" + ], + [ + "mis", + "c" + ], + [ + "\\n *", + "\\n * " + ], + [ + ") / ", + "ONE_20" + ], + [ + "`. ", + "(e.g. number of whitelist mint slots used" + ], + [ + "modul", + "ar " + ], + [ + "paused", + ".\\n */\\n function _" + ], + [ + "_afterTokenTransfer", + "(from, to, amount" + ], + [ + "(value", + ");\\n require(" + ], + [ + "ob", + "serv" + ], + [ + "tokenA", + ", address tokenB" + ], + [ + "[owner", + "]." + ], + [ + "AC", + "L" + ], + [ + "0.6", + "/" + ], + [ + "by the ", + "contract" + ], + [ + "keccak256(", + "'" + ], + [ + "token/ERC20/extensions/", + "draft-" + ], + [ + "token.", + "allowance(address(this), " + ], + [ + "efficient", + "Hash" + ], + [ + "for `owner", + "`. (e.g. number of whitelist mint slots used" + ], + [ + "uint[] memory amounts", + ");\\n function " + ], + [ + ".sol\\\";\\r\\n", + "import \\\"@openzeppelin/contracts/" + ], + [ + "Aux", + "(address owner" + ], + [ + "Subscri", + "be" + ], + [ + "CAN", + "ONICAL" + ], + [ + "ary data ", + "for `owner`. (e.g. number of whitelist mint slots used" + ], + [ + "token.allowance(address(this), ", + "spender" + ], + [ + "(", + ");\\n }\\n\\n function " + ], + [ + ")", + "{" + ], + [ + ",", + "\\n * " + ], + [ + ".", + "\\r\\n * " + ], + [ + "A", + "p" + ], + [ + "E", + "S" + ], + [ + "H", + "en" + ], + [ + "T", + "Values" + ], + [ + "_", + "pric" + ], + [ + "_", + "payload" + ], + [ + "`", + "s` " + ], + [ + "`", + "TokenOwnership` " + ], + [ + "m", + "aster" + ], + [ + "w", + "ere " + ], + [ + "}", + "\\n\\n function " + ], + [ + "s ", + ":= " + ], + [ + "ou", + "gh" + ], + [ + "un", + "packedOwnership" + ], + [ + "a ", + "= " + ], + [ + "el", + "se " + ], + [ + "ee", + "th" + ], + [ + "by ", + "two" + ], + [ + "for", + "ge" + ], + [ + "balanceOf", + "(owner" + ], + [ + "false", + "`.\\n // - `nextInitialized` to `" + ], + [ + "ID", + "ex" + ], + [ + "amount ", + "in case of " + ], + [ + ");\\n ", + "return (true, " + ], + [ + "` and ", + "`to" + ], + [ + ".sol)", + "\\n\\npragma solidity ^0.8." + ], + [ + "last", + "Change" + ], + [ + "reward", + "s " + ], + [ + "one ", + "bit " + ], + [ + "addr", + " = " + ], + [ + "}\\r\\n", + "\"" + ], + [ + ">>= ", + "8" + ], + [ + ") external;\\n\\n /**\\n * @dev ", + "Transfers " + ], + [ + ") external;\\n\\n /**\\n * @dev ", + "Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approv" + ], + [ + "} from \\\"", + "@openzeppelin/contracts/" + ], + [ + "it is ", + "possible to " + ], + [ + "_allTokens", + "Index" + ], + [ + "Revert ", + "if not " + ], + [ + "two", + "s " + ], + [ + "under ", + "MIT licen" + ], + [ + "(\\r\\n address ", + "from" + ], + [ + "5555", + "5555" + ], + [ + "Look", + "up" + ], + [ + "`.\\n ", + "//\\n // " + ], + [ + ") return (false, 0", + ");\\n return (true, " + ], + [ + "allowed ", + "SeaDrop" + ], + [ + "enough ", + "allowance is " + ], + [ + "Updates:\\n // - `", + "balance " + ], + [ + "Does not update the allowance ", + "if the current " + ], + [ + "(bytes32 hash", + ", bytes memory " + ], + [ + "downcasted", + ") {\\n " + ], + [ + "Finish", + "ed" + ], + [ + ") {\\n _check", + "Owner();\\n _" + ], + [ + ", created ", + "from " + ], + [ + "ing.\\n // - `burned` to `", + "false`.\\n // - `nextInitialized` to `" + ], + [ + ") public view virtual override returns (bool) {\\n return _", + "operatorApproval" + ], + [ + "Ori", + "gin" + ], + [ + "Might ", + "emit " + ], + [ + "(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI", + "'s " + ], + [ + "(value);\\n require(", + "downcasted == value, \\\"SafeCast: value doesn't fit in " + ], + [ + "`TokenOwnership` ", + "struct " + ], + [ + "lastChange", + "Block" + ], + [ + "Revert if not ", + "enough allowance is " + ], + [ + "`.\\n //\\n // ", + "We can directly " + ], + [ + "Does not update the allowance if the current ", + "allowance" + ], + [ + "Revert if not enough allowance is ", + "available" + ], + [ + "C", + "ustom" + ], + [ + "F", + "requency" + ], + [ + "N", + "am" + ], + [ + "\\n ", + "uint256 public " + ], + [ + ", ", + "ERC721" + ], + [ + ");", + " " + ], + [ + "ex", + "change" + ], + [ + "uint256 ", + "new" + ], + [ + "ma", + "gn" + ], + [ + "an ", + "infinite " + ], + [ + " = ", + "20" + ], + [ + ");\\n ", + "while (value " + ], + [ + "ant", + "ically " + ], + [ + "only", + "Initializ" + ], + [ + "cl", + "as" + ], + [ + "ta", + "ke " + ], + [ + " is ", + "an " + ], + [ + "log", + "4" + ], + [ + "ra", + "is" + ], + [ + "hash", + "Pair" + ], + [ + "to, ", + "value" + ], + [ + ".\\n * ", + "And also called " + ], + [ + "0 ", + "|| " + ], + [ + "\\n\\t\\t", + "\\t" + ], + [ + "Sell", + "Fees" + ], + [ + ");\\n ", + "value /= 10" + ], + [ + "updated ", + "on" + ], + [ + "scri", + "pt" + ], + [ + "27", + " to " + ], + [ + ")\\n ", + "if (!" + ], + [ + "om", + "ic" + ], + [ + "type", + "\\\":\\\"" + ], + [ + "2**", + "k" + ], + [ + "Cast", + "ed" + ], + [ + "have been ", + "allowed to " + ], + [ + "your ", + "library " + ], + [ + "equivalent to ", + "an infinite " + ], + [ + "is the ", + "maximum `uint256" + ], + [ + "AN", + "CE" + ], + [ + "Stand", + "ard " + ], + [ + "By", + "Sig" + ], + [ + ";\\n\\n // Mapping ", + "owner address to " + ], + [ + "];\\n require(", + "fromBalance " + ], + [ + ". This is ", + "sem" + ], + [ + ",\\n uint256 value", + ",\\n uint256 deadline" + ], + [ + "Govern", + "ance" + ], + [ + "with an ", + "error " + ], + [ + "utils/introspection/IERC165", + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev " + ], + [ + "successful", + " " + ], + [ + "char", + "acter" + ], + [ + "global", + "_" + ], + [ + "0 ? ", + "string(abi.encodePacked(baseURI, " + ], + [ + ".\\n // ", + "Counter overflow is incredibly unrealistic as " + ], + [ + "minting", + ".\\n * And also called " + ], + [ + "@openzeppelin/contracts-", + "0.6/" + ], + [ + "Does not update the allowance ", + "amount in case of " + ], + [ + "maximum `uint256", + "`, the " + ], + [ + "square root ", + "of a " + ], + [ + ".\\n */\\n function _check", + "Owner(" + ], + [ + "-= 1;\\n ", + "buffer[digits] = bytes1(uint8(48 + uint256(value % 10))" + ], + [ + "!= 0) {\\n ", + "digits " + ], + [ + "Base URI for computing {tokenURI}. If set, the resulting URI for each", + "\\n * " + ], + [ + "transferFrom`", + ". This is sem" + ], + [ + "Underflow of the sender's balance is impossible because we check for\\n // ownership above and the recipient's balance can't realistically overflow", + ".\\n // Counter overflow is incredibly unrealistic as " + ], + [ + "this extension", + "'s " + ], + [ + "Throws if the sender is not the owner", + ".\\n */\\n function _checkOwner(" + ], + [ + "allowance is not ", + "updated on" + ], + [ + "(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's ", + "implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits" + ], + [ + ");\\n while (value ", + "!= 0) {\\n digits " + ], + [ + "antically ", + "equivalent to an infinite " + ], + [ + ");\\n value /= 10", + ";\\n }\\n return string(buffer" + ], + [ + "Does not update the allowance amount in case of ", + "infinite allowance" + ], + [ + "maximum `uint256`, the ", + "allowance is not updated on" + ], + [ + "-= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10))", + ");\\n value /= 10;\\n }\\n return string(buffer" + ], + [ + "transferFrom`. This is sem", + "antically equivalent to an infinite " + ], + [ + ");\\n while (value != 0) {\\n digits ", + "-= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer" + ], + [ + "transferFrom`. This is semantically equivalent to an infinite ", + "approval" + ], + [ + " ", + "{\\n " + ], + [ + "(", + "bytes memory " + ], + [ + "N", + "u" + ], + [ + "X", + "X" + ], + [ + "_", + "a" + ], + [ + "_", + "swap" + ], + [ + "_", + "36" + ], + [ + "e", + "f" + ], + [ + "\\n * ", + "by default" + ], + [ + "ing", + "le" + ], + [ + "\\\"", + "}" + ], + [ + "address ", + "from" + ], + [ + "address ", + "payable" + ], + [ + "` ", + "if " + ], + [ + ") {\\n ", + "assembly {\\n // " + ], + [ + "li", + "ties " + ], + [ + "Ex", + "tra " + ], + [ + "0000", + "0" + ], + [ + "length", + " = 0" + ], + [ + "mb", + "in" + ], + [ + ", address ", + "value" + ], + [ + " (", + "i.e. " + ], + [ + "IN", + "TER" + ], + [ + "] = ", + "false" + ], + [ + ";\\n ", + "if (" + ], + [ + "If ", + "`amount` is the " + ], + [ + "address,", + "string" + ], + [ + "ren", + "cy" + ], + [ + "`. ", + "See {" + ], + [ + "isApprovedForAll", + "(from, " + ], + [ + "||", + " _" + ], + [ + "leaf", + "Po" + ], + [ + "` and `", + "numberMinted" + ], + [ + "division by ", + "zero " + ], + [ + "want", + "s to " + ], + [ + "infin", + "ity" + ], + [ + "ATUR", + "E_" + ], + [ + ".\\r\\n *\\r\\n * Requirements:\\r\\n *\\r", + "\\n * - `" + ], + [ + ", // ", + "Toward " + ], + [ + "Development", + "Fee" + ], + [ + "uint256) {\\n // ", + "Counter underflow is impossible " + ], + [ + "`balance", + "` and `numberMinted" + ], + [ + "}.\\n */\\n function isApprovedForAll(address owner, address operator", + ") public view virtual override returns (bool) {\\n return _operatorApproval" + ], + [ + "\\\", \\\"Q", + "m" + ], + [ + "leav", + "es[" + ], + [ + "string memory baseURI = _baseURI", + "();\\n return " + ], + [ + "token will be the concatenation of the `baseURI` and the `tokenId`. Empty", + "\\n * by default" + ], + [ + "Base URI for computing {tokenURI}. If set, the resulting URI for each\\n * ", + "token will be the concatenation of the `baseURI` and the `tokenId`. Empty\\n * by default" + ], + [ + "If `amount` is the ", + "maximum `uint256`, the allowance is not updated on" + ], + [ + "}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApproval", + "s[owner][operator" + ], + [ + "(", + "factory" + ], + [ + "/", + "blob/" + ], + [ + "A", + "ction" + ], + [ + "A", + "ir" + ], + [ + "A", + "vailable" + ], + [ + "D", + "es" + ], + [ + "L", + "in" + ], + [ + "R", + "Values" + ], + [ + "_", + "previou" + ], + [ + "`", + "extraData" + ], + [ + "`", + "msb(a" + ], + [ + "c", + "a" + ], + [ + "in", + "divid" + ], + [ + ", ", + "IERC165" + ], + [ + "ou", + "s " + ], + [ + "ol", + "l" + ], + [ + "` ", + "function" + ], + [ + "of ", + "precision" + ], + [ + "- ", + "if " + ], + [ + "pri", + "vileg" + ], + [ + ". ", + "Compute the " + ], + [ + "max", + "-" + ], + [ + "with ", + "one bit " + ], + [ + "Mint", + "s" + ], + [ + ";\\n }\\n\\n /**\\n * @dev ", + "Base URI for computing {tokenURI}. If set, the resulting URI for each\\n * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\\n * by default" + ], + [ + "per", + "iod " + ], + [ + "id", + "den" + ], + [ + "tokens", + "Swapped" + ], + [ + "@noti", + "ce" + ], + [ + ".\\n *\\n * Emits ", + "a {" + ], + [ + "interface ", + "of an " + ], + [ + "; i", + " < " + ], + [ + "Royalty", + "Info " + ], + [ + "_safeMint", + "(to, quantity" + ], + [ + "getApproved", + "(tokenId" + ], + [ + "curr", + "]" + ], + [ + "bas", + "ed" + ], + [ + "`sender", + "` is the " + ], + [ + "isContract(target), \\\"Address: ", + "delegate " + ], + [ + "KKKKKKKK", + "KKKKKKKK" + ], + [ + "with a ", + "division by zero " + ], + [ + "(data);\\n return verifyCallResult", + "FromTarget" + ], + [ + "\\\");\\n ", + "unchecked {\\n " + ], + [ + "modulo ", + "2^256" + ], + [ + "purch", + "ase " + ], + [ + "power of ", + "2 " + ], + [ + "2**(k", + "/2" + ], + [ + "uint amountToken", + ", uint amount" + ], + [ + "\\\"\\r\\n ", + ");\\r\\n " + ], + [ + "Required ", + "interface of an " + ], + [ + "mload(0x", + "40" + ], + [ + "-st", + "d" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// ERC721A Contract", + "s v4." + ], + [ + "currentAllowance != type(uint256).max", + ") {\\n require(" + ], + [ + "FACE_ID", + "_" + ], + [ + "forge", + "-std" + ], + [ + "with one bit ", + "of precision" + ], + [ + "(data);\\n return verifyCallResultFromTarget", + "(target, " + ], + [ + " ", + "can be " + ], + [ + "\"", + "re" + ], + [ + "(", + "non-" + ], + [ + ".", + "\\n // " + ], + [ + "2", + "25" + ], + [ + "C", + "ast " + ], + [ + "H", + "al" + ], + [ + "w", + "ri" + ], + [ + "to", + ".isContract" + ], + [ + "uint", + "72" + ], + [ + "t ", + "in " + ], + [ + "uint256", + ") " + ], + [ + "\\\"", + "0x00" + ], + [ + "ver", + "se" + ], + [ + "str", + " := sub(" + ], + [ + "ip", + "f" + ], + [ + "Fee", + "Recipient" + ], + [ + "wh", + "o " + ], + [ + "recipient", + " != address(0), \\\"ERC20: " + ], + [ + ", address ", + "approvedAddress" + ], + [ + "ut", + "ch" + ], + [ + "Rol", + "es " + ], + [ + "old", + "Wallet" + ], + [ + "(_", + "from, " + ], + [ + "_mint", + "(msg.sender, " + ], + [ + "Del", + "ay " + ], + [ + "() external view returns (", + "bytes32" + ], + [ + ") internal virtual {\\n ", + "_mint" + ], + [ + "larg", + "e " + ], + [ + "check ", + "if " + ], + [ + "produc", + "t = " + ], + [ + "orac", + "le " + ], + [ + " {\\n /**\\n * @dev Returns the ", + "amount of tokens " + ], + [ + ",\\n bytes memory ", + "userData" + ], + [ + "_startTokenId", + "();\\n " + ], + [ + "########", + "########" + ], + [ + "owned by `from`.\\n * - If the caller is not `from`, it must be ", + "have been allowed to " + ], + [ + "FE", + "ATURE_" + ], + [ + "execut", + "ed " + ], + [ + "_owners[tokenId", + "] = to;\\n\\n emit Transfer" + ], + [ + " == address(0)", + ") revert " + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8", + ".0) (" + ], + [ + "approvedAddressSlot", + ", address approvedAddress" + ], + [ + "getAmounts", + "In" + ], + [ + ") external onlyOwner ", + "{\\r\\n " + ], + [ + "currentAllowance = allowance(owner, spender", + ");\\n if (" + ], + [ + "uniqu", + "e. " + ], + [ + "toHexString(value, ", + "length" + ], + [ + "packed = _", + "packedOwnerships[" + ], + [ + "Alread", + "y" + ], + [ + "s\\n mapping(address => ", + "mapping(address => bool)) private _operatorApprovals" + ], + [ + "The default value of {decimals} is 18. To select a different value for", + "\\n * {decimals} you should overload it.\\n *\\n * " + ], + [ + "string memory baseURI = _baseURI();\\n return ", + "bytes(baseURI).length" + ], + [ + ":", + ": " + ], + [ + "\\", + "\\n" + ], + [ + "j", + "o" + ], + [ + "m", + "any " + ], + [ + "s ", + "can be " + ], + [ + ", ", + "ERC20" + ], + [ + "In", + "h" + ], + [ + "\\r\\n ", + "returns (" + ], + [ + "sender", + " != address(0), \\\"ERC20: " + ], + [ + "ke", + "LP" + ], + [ + ");\\n }\\n\\n /**\\n * @dev ", + "Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner(" + ], + [ + "this ", + "contract" + ], + [ + "pre", + "t" + ], + [ + "emit ", + "a {Role" + ], + [ + "revert", + "ed\"" + ], + [ + " the ", + "first " + ], + [ + ".\\n * ", + "@dev " + ], + [ + "Sell", + " " + ], + [ + "current ", + "nonce " + ], + [ + "\"@openzeppelin/contracts/", + "utils/introspection/ERC165.sol\"" + ], + [ + "\\\\x", + "01" + ], + [ + "unchecked {\\n ", + "if (" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Returns the ", + "address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev " + ], + [ + "fe", + "ature" + ], + [ + ");\\n _", + "afterTokenTransfers" + ], + [ + "Enumerable", + "Set " + ], + [ + "deploy", + "ed " + ], + [ + ";\\r\\n ", + "emit " + ], + [ + "\\r\\n /**\\r\\n * ", + "@notice " + ], + [ + "gu", + "ard" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Returns the ", + "address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev " + ], + [ + "Address ", + "of " + ], + [ + ", bytes32 ", + "indexed " + ], + [ + "interfaceId == ", + "0x" + ], + [ + "sqrt", + "(uint256 a" + ], + [ + "Mask", + " `" + ], + [ + "Whitelist", + "ed" + ], + [ + "system", + " " + ], + [ + "Librar", + "y " + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be ", + "owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to " + ], + [ + "`.\\n ", + "result := " + ], + [ + ") internal virtual {\\n uint256 ", + "currentAllowance = allowance(owner, spender);\\n if (" + ], + [ + ") |", + " _nextExtraData" + ], + [ + ",\\n uint256[] memory ", + "balances" + ], + [ + "May ", + "emit a {Role" + ], + [ + "(token, abi.encodeWithSelector(token.", + "approve.selector, " + ], + [ + "numCheckpoint", + "s" + ], + [ + "(from, address(0), tokenId", + ", 1" + ], + [ + "` to the lower 160 bits, in case the upper bits somehow aren't clean", + ".\\n " + ], + [ + "minim", + "al " + ], + [ + " bits\\\"", + ");\\n }\\n\\n /**\\n * @dev Returns the downcasted " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned", + ".\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId" + ], + [ + ";\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol", + ";\\n\\n // Mapping from token ID to " + ], + [ + ") {\\n _checkOwner();\\n _", + ";\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev " + ], + [ + "Nu", + "keLP" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner(", + ") {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev ", + "Throws if the sender is not the owner.\\n */\\n function _checkOwner(" + ], + [ + ",", + "0" + ], + [ + "5", + "9" + ], + [ + "S", + "CRIP" + ], + [ + "_", + "subtractedValue" + ], + [ + "u", + "ed" + ], + [ + "tr", + "usted " + ], + [ + "length", + "++;\\n temp " + ], + [ + "mapping", + "s\"" + ], + [ + "Contract", + "URI" + ], + [ + "rol", + "es[role]." + ], + [ + "_burn", + "Fee" + ], + [ + "reserve", + "0, " + ], + [ + "_set", + "DefaultRoyalty" + ], + [ + "Delegate", + "Votes" + ], + [ + "Updated", + "(_" + ], + [ + "10000", + "00" + ], + [ + "delegate", + "BySig" + ], + [ + "LP", + "Burn" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n", + "pragma solidity ^0.8.0" + ], + [ + "TRA", + "NSFER" + ], + [ + "token/ERC20/extensions/", + "ERC20Burnable" + ], + [ + "/// @solidity memory-safe-assembly", + "\\n assembly {\\n " + ], + [ + "laun", + "ched" + ], + [ + "interfaces/I", + "ERC2981" + ], + [ + "Quantity", + "Exceeds" + ], + [ + ";\\n }\\n return ", + "toHexString(value, length" + ], + [ + "0.6.", + "2" + ], + [ + "vali", + "dat" + ], + [ + "Und", + "er" + ], + [ + "\\n *", + " " + ], + [ + ";\\n while (temp != 0) {\\n ", + "length++;\\n temp " + ], + [ + "if (value == 0) {\\n return ", + "\\\"0x00" + ], + [ + "\\\";\\n }\\n uint256 temp = value;\\n uint256 ", + "length = 0" + ], + [ + "Pos++", + "] : " + ], + [ + ") internal view virtual {\\n require(", + "owner() == _msgSender(), \\\"Ownable: caller is not the owner" + ], + [ + "(account, address(0), amount);\\n\\n _afterTokenTransfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve", + "(\\n address owner,\\n address spender,\\n uint256 amount\\n " + ], + [ + "token\\n * ", + "by either {approve} or {setApprovalForAll" + ], + [ + "stax", + "Fee" + ], + [ + "(bytes32 hash, bytes memory ", + "signature" + ], + [ + "\"re", + "mappings\"" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev ", + "Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(" + ], + [ + ") internal virtual {\\n uint256 currentAllowance = allowance(owner, spender);\\n if (", + "currentAllowance != type(uint256).max) {\\n require(" + ], + [ + "if (value == 0) {\\n return \\\"0x00", + "\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0" + ], + [ + "if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0", + ";\\n while (temp != 0) {\\n length++;\\n temp " + ], + [ + "6", + "f" + ], + [ + "N", + "AL" + ], + [ + "l", + "z" + ], + [ + "re", + "ach" + ], + [ + "en", + "abl" + ], + [ + "in", + "\\n // " + ], + [ + "un", + "pause" + ], + [ + ".\\n *", + " " + ], + [ + "ing ", + "the zero " + ], + [ + ": ", + "this is " + ], + [ + "s (", + "`approved" + ], + [ + "The ", + "address " + ], + [ + "Se", + "ed" + ], + [ + "burn", + "FeeReceiver" + ], + [ + "Up", + "(" + ], + [ + "buy", + "Fee" + ], + [ + "Counter", + "s for " + ], + [ + "has ", + "no " + ], + [ + ", address indexed ", + "account" + ], + [ + "() external ", + "view override returns (" + ], + [ + "safeMint", + "(\\n address to" + ], + [ + ") internal virtual {\\n require(", + "from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(to != address(0), \\\"ERC20: " + ], + [ + "ownership ", + "slot" + ], + [ + "disable", + "s (`approved" + ], + [ + "\"Address: ", + "unable to send value, recipient may have " + ], + [ + "stored ", + "by the contract" + ], + [ + "Weight", + "ed" + ], + [ + ">= amount, \\\"ERC20: ", + "insufficient allowance" + ], + [ + "multip", + "ly " + ], + [ + ") <= ", + "sqrt(a" + ], + [ + ") <= ", + "a < " + ], + [ + "(address addr", + ") external returns (" + ], + [ + "counter._", + "value" + ], + [ + "owner() == _msgSender(), \\\"Ownable: caller is not the owner", + "\\\");\\n _;\\n }\\n\\n /**\\n * @dev " + ], + [ + "destin", + "ation " + ], + [ + "(address registrant, address ", + "operator" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecim", + "al representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n " + ], + [ + "present.\\n */\\n function ", + "remove(" + ], + [ + ") internal returns (bool) {\\n return _", + "remove(" + ], + [ + "arbitrary ", + "address" + ], + [ + "flash ", + "loan " + ], + [ + "Secondary", + "Sales" + ], + [ + "LOG", + "IC" + ], + [ + ".\\n unchecked {\\n // ", + "Updates:\\n // - `balance " + ], + [ + ") {\\n /// @solidity memory-safe-assembly\\n assembly {\\n ", + "r.slot := " + ], + [ + ") internal view returns (bool) {\\n return _", + "contains(" + ], + [ + "Ethereum Signed Message:", + "\\\\n" + ], + [ + "Slot storage r", + ") {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := " + ], + [ + "is already open", + "\"" + ], + [ + "_getCurrent", + "Supply" + ], + [ + ") internal view returns (uint256) {\\n return _", + "length(" + ], + [ + "_burn(tokenId, ", + "false" + ], + [ + "5` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This ", + "information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `" + ], + [ + "(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits", + ");\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer" + ], + [ + "_previou", + "staxFee" + ], + [ + "uint amountToken, uint amount", + "ETH" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner(", + ") internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner" + ], + [ + ";\\n }\\n return toHexString(value, length", + ");\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecim" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(", + "owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev " + ], + [ + "Counters for ", + "Counters.Counter" + ], + [ + "\"Address: unable to send value, recipient may have ", + "reverted\"" + ], + [ + ") <= sqrt(a", + ") < " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n ", + "if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner", + "\\\");\\n }\\n\\n /**\\n * @dev " + ], + [ + "3", + "f" + ], + [ + "6", + "C" + ], + [ + "v", + "1" + ], + [ + ", ", + "uint256[] memory " + ], + [ + "fun", + "c" + ], + [ + "qu", + "ery" + ], + [ + "========", + "==" + ], + [ + ");\\n ", + "_transfer(from, to, amount" + ], + [ + ";\\n ", + "assembly {\\n " + ], + [ + "(uint256 ", + "x" + ], + [ + "msg.sender", + ", " + ], + [ + "@param", + " " + ], + [ + "!= ", + "address(0)" + ], + [ + "mod", + "ifi" + ], + [ + "allow", + "list" + ], + [ + "entr", + "y" + ], + [ + "chang", + "ed" + ], + [ + ";\\n }\\n\\n function ", + "_" + ], + [ + "fin", + "ish" + ], + [ + ") revert ", + "TransferCallerNotOwnerNorApproved" + ], + [ + "_get", + "TValues" + ], + [ + "set._", + "values[" + ], + [ + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"", + "../../" + ], + [ + "2**", + "64" + ], + [ + "_total", + "Minted" + ], + [ + "includ", + "ing the " + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (", + "token/ERC20/extensions/IERC20Metadata" + ], + [ + "amount exceeds balance", + "\\\");\\n " + ], + [ + "Can", + "not" + ], + [ + "rounding ", + "down" + ], + [ + "uni", + "que" + ], + [ + "Internal ", + "function to " + ], + [ + "address owner = _msgSender(", + ");\\n uint256 " + ], + [ + "loc", + "ated " + ], + [ + "BITMASK_ADDRESS", + ")\\n // " + ], + [ + "_balances[account] = ", + "_balances[account" + ], + [ + "_CACHED", + "_CHAIN_ID" + ], + [ + "requi", + "ring " + ], + [ + "set._inner, bytes32", + "(value" + ], + [ + "\\r\\n *", + "\\r\\n * " + ], + [ + "AddressSet storage set", + ", address value" + ], + [ + "UintSet storage set", + ", uint256 value" + ], + [ + "sort", + "ed" + ], + [ + "_afterTokenTransfers", + "(address(0), to, startTokenId, quantity" + ], + [ + "dividend", + "Tracker" + ], + [ + "] = _packOwnershipData(\\n ", + "to" + ], + [ + "Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer", + "(\\n address from,\\n address to,\\n uint256 amount\\n " + ], + [ + "address spender = _msgSender(", + ");\\n _" + ], + [ + "uint256 fromBalance = _balances[from", + "];\\n require(fromBalance " + ], + [ + "_tokenApprovals;\\n\\n // Mapping from owner to operator approval", + "s\\n mapping(address => mapping(address => bool)) private _operatorApprovals" + ], + [ + "spendAllowance(from, spender, amount", + ");\\n _transfer(from, to, amount" + ], + [ + "getApproved(tokenId", + ") == " + ], + [ + "H", + "istor" + ], + [ + "`", + ".\\n *\\n * Requirements:\\n *\\n * - `from" + ], + [ + "`", + "quantity` " + ], + [ + "c", + "aus" + ], + [ + "c", + " >= " + ], + [ + "→", + " `" + ], + [ + "s ", + "them " + ], + [ + "\\n * ", + "is the maximum `uint256" + ], + [ + "all", + " of " + ], + [ + "address ", + "payable " + ], + [ + "\\n *", + " " + ], + [ + "ERC20", + "Basic" + ], + [ + ".\\n *\\n * ", + "Might emit " + ], + [ + "Transfer", + "Helper" + ], + [ + "over", + "head" + ], + [ + "} ", + "function" + ], + [ + "cre", + "ation" + ], + [ + "0x", + "40" + ], + [ + "UR", + "ATION" + ], + [ + "will ", + "not " + ], + [ + "returns (bool", + ") {\\n return " + ], + [ + ".\\n * ", + "Revert if not enough allowance is available" + ], + [ + "an {Approval", + "} event.\\n */\\n function _" + ], + [ + "_get", + "RValues" + ], + [ + "0000000000000000", + "00000000" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (", + "utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev " + ], + [ + "currentAllowance ", + ">= amount, \\\"ERC20: insufficient allowance" + ], + [ + " (when the ", + "result is negative" + ], + [ + "Start", + "Time" + ], + [ + "move this ", + "token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function " + ], + [ + "ONE_", + "18" + ], + [ + "== 0) {\\n return ", + "0;\\n " + ], + [ + "MAX_", + "MINT_" + ], + [ + "address owner = _msgSender();\\n ", + "_approve(owner, spender, " + ], + [ + "╬╬╬╬", + "╬╬╬╬" + ], + [ + ") internal returns (bytes memory) {\\n require(", + "isContract(target), \\\"Address: delegate " + ], + [ + "}.\\n *\\n * NOTE: ", + "Does not update the allowance if the current allowance" + ], + [ + ";\\n\\nimport '", + "./" + ], + [ + "Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {", + "safeTransferFrom} " + ], + [ + "Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll", + "}\\n */\\n function " + ], + [ + "rely ", + "on " + ], + [ + "Map ", + "storage " + ], + [ + "Wrappers ", + "over " + ], + [ + ") internal virtual {}\\n\\n /**\\n * @dev Hook that is called after any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * has been transferred to `to`.\\n * - when `from` is zero, `amount` tokens have been minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer", + "(\\n address from,\\n address to,\\n uint256 amount\\n " + ], + [ + "if (nextTokenId ", + "!= " + ], + [ + "` and `to", + "` cannot be the zero address.\\n * - `" + ], + [ + ") external;\\n\\n /**\\n * @dev Transfers ", + "`tokenId` token from `from` to `to" + ], + [ + ") external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approv", + "ing the zero " + ], + [ + "SCRIP", + "TION" + ], + [ + "Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n ", + ") internal virtual {}\\n\\n /**\\n * @dev Hook that is called after any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * has been transferred to `to`.\\n * - when `from` is zero, `amount` tokens have been minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n " + ], + [ + "address spender = _msgSender();\\n _", + "spendAllowance(from, spender, amount);\\n _transfer(from, to, amount" + ], + [ + "`.\\n *\\n * Requirements:\\n *\\n * - `from", + "` and `to` cannot be the zero address.\\n * - `" + ], + [ + "\\n * is the maximum `uint256", + "`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `" + ], + [ + ".\\n *\\n * Might emit ", + "an {Approval} event.\\n */\\n function _" + ], + [ + ".\\n * Revert if not enough allowance is available", + ".\\n *\\n * Might emit an {Approval} event.\\n */\\n function _" + ], + [ + "}.\\n *\\n * NOTE: Does not update the allowance if the current allowance", + "\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `" + ], + [ + "Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function ", + "isApprovedForAll(address owner, address operator" + ], + [ + ") external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero ", + "address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId" + ], + [ + ".\\n * Revert if not enough allowance is available.\\n *\\n * Might emit an {Approval} event.\\n */\\n function _", + "spendAllowance" + ], + [ + " ", + "bytes" + ], + [ + "4", + "9" + ], + [ + "4", + "a" + ], + [ + "V", + "esting" + ], + [ + "v", + "` " + ], + [ + "•", + "´" + ], + [ + "\\n ", + "}\\n }\\n\\n /**\\n * @dev " + ], + [ + "ti", + "er-" + ], + [ + ", ", + "add(" + ], + [ + "token", + "In" + ], + [ + "end", + " " + ], + [ + "is", + "Owner" + ], + [ + "amount", + "Received" + ], + [ + "\\n\\n ", + "// The " + ], + [ + ") external ", + "pure returns (" + ], + [ + "approve", + "}.\\n *\\n * NOTE: " + ], + [ + "tokens ", + "in " + ], + [ + "role", + "Member" + ], + [ + "ed by ", + "{" + ], + [ + "implement", + " the " + ], + [ + "line", + "-" + ], + [ + "emp", + "tion" + ], + [ + "Reward", + "s(" + ], + [ + ";\\n }\\n\\n ", + "/// @dev " + ], + [ + "Error", + "s" + ], + [ + "\\n * `", + "transferFrom`. This is semantically equivalent to an infinite approval" + ], + [ + "`.\\n *\\n * ", + "Does not update the allowance amount in case of infinite allowance" + ], + [ + "https://eips.ethereum.org/EIPS/eip-", + "2" + ], + [ + ";\\n }\\n ", + "if (" + ], + [ + "exists", + "(uint256 tokenId" + ], + [ + "we", + "'re " + ], + [ + ");\\n\\n /**\\n * @dev Emitted when ", + "`value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value" + ], + [ + "token/ERC20/ERC20", + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./" + ], + [ + "super._", + "beforeTokenTransfer" + ], + [ + "release", + "Time" + ], + [ + "`. This ", + "value " + ], + [ + "from` must have a balance of at least `amount", + "`.\\n * - the caller must have allowance for " + ], + [ + "Txn", + "Amount" + ], + [ + ";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString", + "(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer" + ], + [ + " <= a", + ", errorMessage" + ], + [ + "If `to` refers to a smart contract, it must implement", + "\\n * {" + ], + [ + ">>= 8", + ";\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecim" + ], + [ + ",\\n uint256 value,\\n uint256 deadline", + ",\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n " + ], + [ + "pret", + "tier-" + ], + [ + "disables (`approved", + "`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp ", + ">>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecim" + ], + [ + "}.\\n *\\n * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `", + "from` must have a balance of at least `amount`.\\n * - the caller must have allowance for " + ], + [ + "`.\\n *\\n * Does not update the allowance amount in case of infinite allowance", + ".\\n * Revert if not enough allowance is available.\\n *\\n * Might emit an {Approval} event.\\n */\\n function _spendAllowance" + ], + [ + ";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer", + ");\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecim" + ], + [ + "prettier-", + "ignore" + ], + [ + "-", + "based" + ], + [ + "1", + " << (" + ], + [ + "3", + "a" + ], + [ + "3", + "64" + ], + [ + "E", + "8" + ], + [ + "^", + " b" + ], + [ + "_", + "must" + ], + [ + "s", + "_" + ], + [ + "address", + "\"" + ], + [ + "to ", + "use " + ], + [ + "a ", + "^ b" + ], + [ + "Token", + "In" + ], + [ + "s.", + "add(" + ], + [ + "min", + "ut" + ], + [ + ";\\n", + "pragma " + ], + [ + "IN", + "on" + ], + [ + ",\\n uint256 ", + "b" + ], + [ + "// S", + "ee: " + ], + [ + "Total", + " " + ], + [ + "emit ", + "OwnershipTransferred(" + ], + [ + "rol", + "e that " + ], + [ + ") {\\n ", + "if (" + ], + [ + "\"@openzeppelin/contracts/", + "token/ERC20/extensions/IERC20Metadata.sol\"" + ], + [ + ".\\n ", + "return " + ], + [ + "Enumer", + "able is " + ], + [ + "27", + " or " + ], + [ + "dep", + "ending " + ], + [ + "allowed", + "Nft" + ], + [ + "De", + "bt" + ], + [ + "(1", + " << _" + ], + [ + "string,", + "uint," + ], + [ + "slot", + ") internal pure returns (" + ], + [ + "EN", + "S" + ], + [ + "with the ", + "registry " + ], + [ + "(bytes32 ", + "slot) internal pure returns (" + ], + [ + "`value` ", + "located " + ], + [ + "_maxWallet", + "Token" + ], + [ + ".\\n *\\n * Calling conditions:\\n *\\n * - ", + "When `from` and `to` are both non-zero, `from`'s " + ], + [ + "_approve(owner, ", + "spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20" + ], + [ + "] = _", + "HEX_SYMBOLS" + ], + [ + "origin", + "ated " + ], + [ + "0 ? ", + "0 : " + ], + [ + "``owner``'s ", + "account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to" + ], + [ + "neg", + "ative " + ], + [ + "` with ", + "member " + ], + [ + "to` cannot be the zero address", + ".\\n * - the caller must have a balance of at least `amount`.\\n */\\n function " + ], + [ + "security/", + "Pausable" + ], + [ + "2**(", + "log2(a" + ], + [ + "on-", + "chain " + ], + [ + "HEX_SYMBOLS", + " = \\\"0123456789abcdef" + ], + [ + "returndatasize", + "())" + ], + [ + "`.\\n _", + "packedAddressData" + ], + [ + "_balances[to] += ", + "1;\\n " + ], + [ + "_previous", + "redisFee" + ], + [ + "numberOf", + "Tokens" + ], + [ + "`hash", + "` " + ], + [ + "xC", + "vx" + ], + [ + "ERC721Metadata", + ": URI " + ], + [ + "at `", + "slot" + ], + [ + "result < ", + "value ? 1 : 0" + ], + [ + ", address[] calldata path", + ", address to, " + ], + [ + "seriesSum", + " += " + ], + [ + "Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or ", + "disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in " + ], + [ + "`.\\n *\\n * This internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer", + "} event" + ], + [ + "cheap", + "er than " + ], + [ + "/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an ", + "invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function " + ], + [ + "_approve(owner, spender, currentAllowance - amount", + ");\\n }\\n }\\n }\\n\\n /**\\n * @dev " + ], + [ + "If `amount` is the maximum `uint256`, the allowance is not updated on", + "\\n * `transferFrom`. This is semantically equivalent to an infinite approval" + ], + [ + "max-", + "line-" + ], + [ + "] = _packOwnershipData(\\n to", + ",\\n _" + ], + [ + "approve}.\\n *\\n * NOTE: ", + "If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval" + ], + [ + ";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecim", + "al representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i" + ], + [ + "27 or ", + "28" + ], + [ + "`value` located ", + "at `slot" + ], + [ + "_approve(owner, spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20", + "}.\\n *\\n * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n * - the caller must have allowance for " + ], + [ + "` with member ", + "`value` located at `slot" + ], + [ + ", address[] calldata path, address to, ", + "uint deadline" + ], + [ + "max-line-", + "length" + ], + [ + "(", + "i.e. `" + ], + [ + "^", + "^" + ], + [ + "l", + "en" + ], + [ + "s", + "ent to " + ], + [ + "s ", + "should be " + ], + [ + "co", + "mbin" + ], + [ + ".\\n */\\n function ", + "recover" + ], + [ + "ant", + "i" + ], + [ + "32", + " bytes " + ], + [ + "), ", + "true" + ], + [ + ");\\n\\n ", + "_afterTokenTransfer" + ], + [ + ").", + "transfer" + ], + [ + "Role", + "Grant" + ], + [ + "constructor", + "(\\n " + ], + [ + "any ", + "token transfer" + ], + [ + "96", + "(" + ], + [ + "remove", + "AllFee" + ], + [ + "me", + "/" + ], + [ + "/**\\n * @notice ", + "Calculates " + ], + [ + "Recover", + "y" + ], + [ + ";\\n\\n /**\\n * @dev ", + "Initializes the contract " + ], + [ + "RA", + "RE" + ], + [ + "\"SafeMath: ", + "modulo by " + ], + [ + "operation ", + "for " + ], + [ + "this function ", + "is " + ], + [ + "struct", + "s/" + ], + [ + "contain", + "s " + ], + [ + "super.", + "_transfer" + ], + [ + "getApproved", + "SlotAndAddress" + ], + [ + "off", + "set " + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `", + "from` must have a balance of at least `amount" + ], + [ + "manag", + "ed " + ], + [ + "0.7", + "." + ], + [ + "(hash", + ", v, r, s" + ], + [ + "%%%%", + "%%%%" + ], + [ + "can then ", + "be " + ], + [ + "(from, to, amount);\\n\\n ", + "_afterTokenTransfer(from, to, amount" + ], + [ + "(from, to, amount);\\n\\n ", + "uint256 fromBalance = _balances[from];\\n require(fromBalance " + ], + [ + "address(0x", + "dead" + ], + [ + "r` and `", + "s` " + ], + [ + "fixed point ", + "number" + ], + [ + "Overload of {ECDSA-", + "recover" + ], + [ + "_O", + "FFSET" + ], + [ + "on\\n * division by zero. The result is rounded towards ", + "zero.\\n *\\n * Counterpart to Solidity's `" + ], + [ + "nonces[", + "owner" + ], + [ + "\\\");\\n unchecked {\\n ", + "_approve(owner, spender, currentAllowance - amount);\\n }\\n }\\n }\\n\\n /**\\n * @dev " + ], + [ + "Required interface of an ", + "ERC721 " + ], + [ + "(data);\\n return verifyCallResultFromTarget(target, ", + "success, returndata, errorMessage" + ], + [ + "`.\\n *\\n * This internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event", + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount" + ], + [ + "/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function ", + "div" + ], + [ + "approve}.\\n *\\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval", + ".\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount" + ], + [ + "`.\\n *\\n * This internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount", + "`.\\n */\\n function _transfer" + ], + [ + ")", + ",\\n " + ], + [ + ",", + "\\n // " + ], + [ + ":", + "\\n * " + ], + [ + "A", + "F" + ], + [ + "G", + "auge" + ], + [ + "_", + "current" + ], + [ + "a", + "\\n * " + ], + [ + "r", + "ing the " + ], + [ + "t", + "ed by " + ], + [ + ", ", + "rounded down" + ], + [ + "ou", + "ghtEarly" + ], + [ + "//", + "/" + ], + [ + "To", + "Mint" + ], + [ + "ma", + "il" + ], + [ + "st", + "ack" + ], + [ + "si", + "de" + ], + [ + ".\\n */\\n function ", + "mulDiv" + ], + [ + ";\\n ", + "}\\n }\\n\\n function " + ], + [ + "sender", + "` and `" + ], + [ + " is ", + "a " + ], + [ + ";\\n\\n ", + "uint256 public " + ], + [ + "param", + "s" + ], + [ + "0x", + "00000000000000000000000000000000" + ], + [ + " * ", + "10**" + ], + [ + "result ", + "of a " + ], + [ + "Role", + "Revoked(" + ], + [ + "data ", + "bytes " + ], + [ + "= _", + "currentIndex" + ], + [ + ") public virtual ", + "{\\n " + ], + [ + "\\\");\\n\\n ", + "_" + ], + [ + ") internal view virtual ", + "override returns (" + ], + [ + "Set ", + "_inner" + ], + [ + "_tax", + "FeeOnBuy" + ], + [ + "project", + "s[" + ], + [ + "stand", + "ardiz" + ], + [ + "Address ", + "of the " + ], + [ + "each ", + "step" + ], + [ + "RoleAdmin", + "Changed(" + ], + [ + "`, it ", + "is the " + ], + [ + "\\n\\t *", + "/" + ], + [ + "the `", + "Transfer` " + ], + [ + "twos", + ")\\n\\n // " + ], + [ + "set._inner, ", + "index" + ], + [ + "MMMMMMMMMMMMMMMM", + "MMMMMMMMMMMMMMMM" + ], + [ + "at(", + "set._inner, index" + ], + [ + "result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n ", + "result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n " + ], + [ + "as part ", + "of a " + ], + [ + ");\\n }\\n ", + "if (" + ], + [ + "manual", + "Swap" + ], + [ + "present.\\n */\\n function ", + "add(" + ], + [ + ") internal returns (bool) {\\n return _", + "add(" + ], + [ + "the contract ", + "call" + ], + [ + " TH", + "IS" + ], + [ + "in the set. O(1).\\n */\\n function ", + "contains(" + ], + [ + "_approve(address(0), ", + "tokenId);\\n\\n " + ], + [ + "Set {\\n ", + "Set _inner" + ], + [ + "Returns true if the value is ", + "in the set. O(1).\\n */\\n function contains(" + ], + [ + "Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * ", + "present.\\n */\\n function remove(" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already ", + "present.\\n */\\n function add(" + ], + [ + "account that ", + "originated " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Returns the number of ", + "values " + ], + [ + "\"trading ", + "is already open\"" + ], + [ + "by two", + "s.\\n " + ], + [ + "infinity", + "\\n " + ], + [ + "- if ", + "using `" + ], + [ + "`sender` is the ", + "account that originated " + ], + [ + "The default value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * ", + "All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5.0" + ], + [ + ", address indexed account", + ", address indexed sender" + ], + [ + ") internal virtual {\\n require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(to != address(0), \\\"ERC20: ", + "transfer to the zero address\\\");\\n\\n _beforeTokenTransfer" + ], + [ + ") internal view returns (uint256) {\\n return _length(", + "set._inner" + ], + [ + "if (nextTokenId != ", + "_currentIndex" + ], + [ + "emit OwnershipTransferred(", + "_owner" + ], + [ + "to` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function ", + "transfer(address to, uint256 amount" + ], + [ + "Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ", + "``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to" + ], + [ + "RoleGrant", + "ed(" + ], + [ + "any token transfer", + ". This includes " + ], + [ + "\"SafeMath: modulo by ", + "zero\"" + ], + [ + "standardiz", + "ed " + ], + [ + "Set {\\n Set _inner", + ";\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(" + ], + [ + "`sender` is the account that originated ", + "the contract call" + ], + [ + " ", + "C" + ], + [ + " ", + "^ " + ], + [ + "(", + "address,address," + ], + [ + "1", + "\\\"" + ], + [ + "B", + "URN" + ], + [ + "\\n", + "* " + ], + [ + "\\n", + "pragma solidity >=" + ], + [ + "s ", + "for the " + ], + [ + "in", + "el" + ], + [ + "ac", + "tive " + ], + [ + "or", + "y" + ], + [ + "at", + "tribu" + ], + [ + "token", + "s/" + ], + [ + ".s", + "wap" + ], + [ + "public ", + "immutable " + ], + [ + "new", + "Votes" + ], + [ + "0.", + "9" + ], + [ + "_transfer", + ":: " + ], + [ + "_approve", + "(address(this), " + ], + [ + "Min", + "imum" + ], + [ + " for ", + "a " + ], + [ + " == ", + "0) {\\n " + ], + [ + "chang", + "e the " + ], + [ + ") external", + ";\\r\\n" + ], + [ + ";\\n ", + "// " + ], + [ + "temp", + ", " + ], + [ + ");\\n function ", + "get" + ], + [ + "trading", + "Enabled" + ], + [ + "UN", + "COMM" + ], + [ + "calling ", + "{" + ], + [ + ") public virtual override returns (bool) {\\n ", + "address spender = _msgSender();\\n _spendAllowance(from, spender, amount);\\n _transfer(from, to, amount" + ], + [ + "\\n // =============================================================\\n\\n /**\\n * @dev ", + "Returns the " + ], + [ + "VER", + "Y " + ], + [ + "chain ", + "id " + ], + [ + "Overflow", + "s are " + ], + [ + "necess", + "ary" + ], + [ + "order ", + "of the " + ], + [ + "(x, ", + "y" + ], + [ + "░░░░░░░░", + "░░░░░░░░" + ], + [ + "this is ", + "by " + ], + [ + "codeHash", + "es" + ], + [ + "Uniswap", + "V3" + ], + [ + " to be transferred", + ".\\n * " + ], + [ + "_setup", + "Role" + ], + [ + "address that ", + "signed " + ], + [ + "IERC20Permit", + "-" + ], + [ + "` in packed ", + "address data.\\n uint256 private constant _" + ], + [ + ">= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n unchecked {\\n ", + "_balances[from] = fromBalance - amount" + ], + [ + "bit in packed ", + "ownership.\\n uint256 private constant _" + ], + [ + "compliant contract.\\n */\\ninterface ", + "IERC721" + ], + [ + "Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} ", + "for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved" + ], + [ + "Required interface of an ERC721 ", + "compliant contract.\\n */\\ninterface IERC721" + ], + [ + " ", + "✓" + ], + [ + ".", + "push" + ], + [ + "D", + "S" + ], + [ + "P", + "t" + ], + [ + "W", + "eb" + ], + [ + "_", + "QU" + ], + [ + "`", + "\\n // " + ], + [ + "c", + "d" + ], + [ + "s", + "!" + ], + [ + "t", + "Liquidity" + ], + [ + "\\n ", + "returns (" + ], + [ + "on", + "\\r\\n * " + ], + [ + "uint", + ");\\n\\n function " + ], + [ + ") ", + "signatures" + ], + [ + "token", + "omic" + ], + [ + "address ", + "can then be " + ], + [ + "a ", + "hashed " + ], + [ + "` ", + "EVM " + ], + [ + "of ", + "its " + ], + [ + "str", + "ategy " + ], + [ + ": ", + "it is possible to " + ], + [ + "ee", + "p" + ], + [ + "be ", + "too long" + ], + [ + " to ", + "arbitrary address" + ], + [ + "by ", + "requi" + ], + [ + "swap", + " and " + ], + [ + "hash", + "`) " + ], + [ + "in the ", + "lower" + ], + [ + "fee", + "Recipient" + ], + [ + "Pool", + "s " + ], + [ + "from, ", + "tokenId, _data" + ], + [ + ", and ", + "the `" + ], + [ + "non-", + "hashed " + ], + [ + "ENT", + " THIS" + ], + [ + "`.\\n *\\n * ", + "`sender` is the account that originated the contract call" + ], + [ + "then ", + "calling {" + ], + [ + "no ", + "longer " + ], + [ + "recover", + " to arbitrary address" + ], + [ + "either ", + "27 or 28" + ], + [ + "ing a ", + "hash of the " + ], + [ + "message ", + "(`" + ], + [ + "message ", + "(which " + ], + [ + "this function ", + "reject" + ], + [ + "A ", + "safe " + ], + [ + "_currentIndex", + " = " + ], + [ + " to be ", + "secure" + ], + [ + "_ ", + "be the " + ], + [ + "cr", + "aft " + ], + [ + "opcode ", + "allows for " + ], + [ + "IMPORTANT: ", + "UNCOMM" + ], + [ + "Param", + "et" + ], + [ + "checkpoint", + "s[account" + ], + [ + "state", + "-" + ], + [ + "data. ", + "A safe " + ], + [ + "hash ", + "operation for " + ], + [ + "way to ", + "ensure" + ], + [ + ")\\n", + "\\n // " + ], + [ + ");\\n\\n /**\\n * @dev Emitted when ", + "`account` is " + ], + [ + "norm", + "al " + ], + [ + "ecrecover", + "` EVM " + ], + [ + "es for ", + "non-hashed " + ], + [ + "used for ", + "verification " + ], + [ + " L", + "ATER" + ], + [ + "Enabl", + "ed " + ], + [ + "``from``'s ", + "tokens of at least\\n * `amount`.\\n */\\n function transferFrom" + ], + [ + "VRF", + " " + ], + [ + ",\\r\\n address to", + ",\\r\\n " + ], + [ + "explicit", + "ly " + ], + [ + "When `from` and `to` are both non-zero, ", + "``from``'s " + ], + [ + "toEthSignedMessageHash", + "} on " + ], + [ + "Hand", + "ler" + ], + [ + "original ", + "message (which " + ], + [ + "=-=-", + "=-=-" + ], + [ + "_approve(owner, spender, currentAllowance ", + "- subtractedValue);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves `amount` of tokens from " + ], + [ + "malleable ", + "(non-" + ], + [ + "value to be ", + "in the lower" + ], + [ + "value to be ", + "either 27 or 28" + ], + [ + "} that receives the `", + "v" + ], + [ + "_Available since v3.", + "4._" + ], + [ + "bytes32[] calldata ", + "proof" + ], + [ + "Setting", + "s" + ], + [ + "half order", + ", and the `" + ], + [ + "bytes32 indexed role", + ", address indexed account, address indexed sender" + ], + [ + "verification", + " to be secure" + ], + [ + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n ", + "address owner = _msgSender();\\n _approve(owner, spender, " + ], + [ + "), and ", + "then calling {" + ], + [ + "addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n ", + "address owner = _msgSender();\\n uint256 " + ], + [ + "bil", + "ity " + ], + [ + "receiv", + "ing a hash of the " + ], + [ + "_transfer(owner, to, amount", + ");\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-" + ], + [ + "`s` ", + "value to be in the lower" + ], + [ + "(\\r\\n address from", + ",\\r\\n address to,\\r\\n uint256 " + ], + [ + "_safeMint(to, quantity", + ", ''" + ], + [ + "unique", + ") signatures" + ], + [ + "s them ", + "by requi" + ], + [ + "v` ", + "value to be either 27 or 28" + ], + [ + "_must", + "_ be the " + ], + [ + "`hash` ", + "_must_ be the " + ], + [ + "_approve(owner, spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n * - the caller must have allowance for ", + "``from``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom" + ], + [ + "r` and `s` ", + "signature fields separately" + ], + [ + "ring the ", + "`s` value to be in the lower" + ], + [ + "result of a ", + "hash operation for " + ], + [ + ") internal virtual {\\n require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(to != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer", + "(from, to, amount);\\n\\n uint256 fromBalance = _balances[from];\\n require(fromBalance " + ], + [ + "VERY ", + "IMPORTANT: UNCOMM" + ], + [ + "this is by ", + "receiving a hash of the " + ], + [ + "address that signed ", + "a hashed " + ], + [ + "address can then be ", + "used for verification " + ], + [ + ": it is possible to ", + "craft " + ], + [ + "be too long", + "), and then calling {" + ], + [ + "ENT THIS", + " LATER" + ], + [ + "recover to arbitrary address", + "es for non-hashed " + ], + [ + "message (`", + "hash`) " + ], + [ + "this function reject", + "s them by requi" + ], + [ + "opcode allows for ", + "malleable (non-" + ], + [ + "data. A safe ", + "way to ensure" + ], + [ + "ecrecover` EVM ", + "opcode allows for malleable (non-" + ], + [ + "toEthSignedMessageHash} on ", + "it" + ], + [ + "original message (which ", + "may " + ], + [ + "half order, and the `", + "v` value to be either 27 or 28" + ], + [ + "verification to be secure", + ": it is possible to craft " + ], + [ + "`hash` _must_ be the ", + "result of a hash operation for " + ], + [ + "VERY IMPORTANT: UNCOMM", + "ENT THIS LATER" + ], + [ + "this is by receiving a hash of the ", + "original message (which may " + ], + [ + "address that signed a hashed ", + "message (`hash`) " + ], + [ + "be too long), and then calling {", + "toEthSignedMessageHash} on it" + ], + [ + "recover to arbitrary addresses for non-hashed ", + "data. A safe way to ensure" + ], + [ + "this function rejects them by requi", + "ring the `s` value to be in the lower" + ], + [ + "ecrecover` EVM opcode allows for malleable (non-", + "unique) signatures" + ], + [ + "verification to be secure: it is possible to craft ", + "signatures " + ], + [ + ")", + "\\n * " + ], + [ + ")", + ");\\n }\\n}\\n\"" + ], + [ + "/", + "I" + ], + [ + "_", + "last" + ], + [ + "f", + "ur" + ], + [ + "}", + ".\\n */\\n function _" + ], + [ + "e ", + "for " + ], + [ + "s ", + "if " + ], + [ + "/**", + "\\n\\t * " + ], + [ + "Su", + "ccess" + ], + [ + "\\r\\n", + "// " + ], + [ + ") external ", + "onlyOwner {\\n require(" + ], + [ + ", uint256 ", + "_value" + ], + [ + "cre", + "dit" + ], + [ + "With", + "out" + ], + [ + ") {\\n ", + "uint256 " + ], + [ + ") internal pure returns (", + "bytes32) {\\n return " + ], + [ + "is not ", + "active" + ], + [ + "pair", + " of " + ], + [ + "sto", + "p " + ], + [ + "account ", + "had" + ], + [ + "round", + "s " + ], + [ + "Typ", + "e " + ], + [ + "initial", + "ETHBalance" + ], + [ + "protocol", + "SwapFeePercentage" + ], + [ + "cop", + "i" + ], + [ + "(address(0), to, ", + "tokenId" + ], + [ + "_P", + "RIC" + ], + [ + "uint256,", + "uint256," + ], + [ + "rewards", + "Token" + ], + [ + "_EX", + "P" + ], + [ + "[from", + "]" + ], + [ + "otherwis", + "e\\n * " + ], + [ + "Requ", + "est " + ], + [ + "multip", + "lying " + ], + [ + "Fungi", + "ble" + ], + [ + "& _", + "BITMASK_ADDRESS_DATA_ENTRY;\\n }\\n\\n /**\\n * Returns the " + ], + [ + "amountTo", + "Liquify" + ], + [ + "_CACHED", + "_DOMAIN_SEPARATOR" + ], + [ + ") public virtual override returns (bool) {\\n address owner = _msgSender();\\n ", + "_transfer(owner, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-" + ], + [ + "restore", + "AllFee" + ], + [ + "spl", + "it" + ], + [ + "IG", + "H" + ], + [ + "\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly", + "\\n" + ], + [ + "(proof", + ", " + ], + [ + "Delay ", + "enabled" + ], + [ + ") internal virtual {\\n uint256 currentAllowance = allowance(owner, spender);\\n if (currentAllowance != type(uint256).max) {\\n require(", + "currentAllowance >= amount, \\\"ERC20: insufficient allowance" + ], + [ + "] = _HEX_SYMBOLS", + "[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer" + ], + [ + "address can then be used for verification ", + "purposes" + ], + [ + ") internal virtual {\\n uint256 currentAllowance = allowance(owner, spender);\\n if (currentAllowance != type(uint256).max) {\\n require(currentAllowance >= amount, \\\"ERC20: insufficient allowance", + "\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - amount);\\n }\\n }\\n }\\n\\n /**\\n * @dev " + ], + [ + " ", + "post" + ], + [ + "\"", + "erc721a/contracts/" + ], + [ + "<", + "= _" + ], + [ + "_", + "00" + ], + [ + "a", + "'" + ], + [ + "a", + ",\\n uint256 b" + ], + [ + "th", + "er" + ], + [ + "th", + "ing" + ], + [ + "the ", + "same " + ], + [ + "am", + "t" + ], + [ + ".\\n */\\n function ", + "set" + ], + [ + ", uint256 ", + "tokenId" + ], + [ + "ist", + "anbul" + ], + [ + "override ", + "this function" + ], + [ + "Si", + "ze " + ], + [ + "Wallet", + "s" + ], + [ + "_approve", + "(to, tokenId" + ], + [ + "https://", + "eth" + ], + [ + "next", + "Slot" + ], + [ + ", _", + "BITMASK_ADDRESS)\\n // " + ], + [ + "app", + "ly " + ], + [ + "NOT", + " " + ], + [ + "() external ", + "onlyOwner {\\n " + ], + [ + "key", + "Hash" + ], + [ + "LO", + "AD" + ], + [ + "SeaDrop", + "Token" + ], + [ + "(\\n uint256 ", + "a,\\n uint256 b" + ], + [ + "Manag", + "er " + ], + [ + "role, account", + ", _msgSender()" + ], + [ + "utils/introspection/IERC165", + ".sol\\\";\\n\\n/**\\n * @dev " + ], + [ + "codeHash", + "es " + ], + [ + "allowance(owner, spender", + ") + " + ], + [ + "deposi", + "tor" + ], + [ + "`value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value", + ");\\n\\n /**\\n * @dev Returns the amount of tokens " + ], + [ + "Coordin", + "ator" + ], + [ + "expos", + "ed" + ], + [ + "(_packedAddressData[owner] ", + ">> _" + ], + [ + "` with member `value` located at `slot", + "`.\\n */\\n function get" + ], + [ + "approve}.\\n *\\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount", + ") public virtual override returns (bool) {\\n address owner = _msgSender();\\n " + ], + [ + "The default value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5.0", + "5` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `" + ], + [ + "to` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address to, uint256 amount", + ") public virtual override returns (bool) {\\n address owner = _msgSender();\\n _transfer(owner, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-" + ], + [ + ") public virtual override returns (bool) {\\n address spender = _msgSender();\\n _spendAllowance(from, spender, amount);\\n _transfer(from, to, amount", + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, " + ], + [ + "to` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address to, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _transfer(owner, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-", + "approve}.\\n *\\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n " + ], + [ + "!", + "!" + ], + [ + "\"", + "P" + ], + [ + "P", + "ause" + ], + [ + "_", + "id" + ], + [ + "b", + "in" + ], + [ + "c", + "2" + ], + [ + "s", + "lo" + ], + [ + "w", + "eth" + ], + [ + "\\n", + "/// @author " + ], + [ + "\\n ", + "view" + ], + [ + "er", + "min" + ], + [ + "tr", + "usted" + ], + [ + "ed ", + "or " + ], + [ + "amount", + " = " + ], + [ + "is ", + "lo" + ], + [ + "Id", + ", " + ], + [ + "con", + "vert" + ], + [ + "able", + "Amount" + ], + [ + "\\r\\n ", + "uint256 " + ], + [ + ");\\n }\\n\\n /**\\n * @dev ", + "Approve " + ], + [ + "mapping", + "(bytes32 => " + ], + [ + "amp", + "le " + ], + [ + "pre", + "view" + ], + [ + "allow", + "ing " + ], + [ + "ect", + "ed" + ], + [ + "encode", + "WithSelector" + ], + [ + "Max", + "imum" + ], + [ + "Ownable", + ", " + ], + [ + ");\\r\\n ", + "}\\r\\n }\\r\\n" + ], + [ + "ren", + "ce" + ], + [ + ");\\n }\\n\\n /**\\n * @dev S", + "afely transfers `tokenId` token from `from` to `to" + ], + [ + "];\\n ", + "if (" + ], + [ + "`spender` ", + "based on " + ], + [ + "$$", + " |" + ], + [ + " to be ", + "minted" + ], + [ + "revoke", + "Role(role, account);\\n }\\n\\n /**\\n * @dev " + ], + [ + "As", + "sum" + ], + [ + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../", + "IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\"" + ], + [ + "[to", + "] += " + ], + [ + "State", + "." + ], + [ + "short", + "-" + ], + [ + "startTokenId ", + "= _currentIndex" + ], + [ + "timelock", + "_address" + ], + [ + "Multip", + "le" + ], + [ + "counter._", + "value = " + ], + [ + "\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.", + "13" + ], + [ + "`,", + "\\n * `" + ], + [ + "never ", + "be " + ], + [ + "commun", + "ity" + ], + [ + "nomin", + "al" + ], + [ + "experiment", + "al " + ], + [ + "operator-filter-registry/", + "src/" + ], + [ + "OpenZeppelin Contracts guidelines: functions revert\\n * instead returning `false` on failure. This behavior is nonetheless\\n * conventional and does not conflict with the expectations of ERC20\\n * applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping(address => uint256) private _balances;\\n\\n mapping(address => mapping(address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * ", + "The default value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5.05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `" + ], + [ + "Interes", + "t" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev ", + "Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\"" + ], + [ + ";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i", + "] = _HEX_SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer" + ], + [ + "(from, to, amount);\\n\\n _afterTokenTransfer(from, to, amount", + ");\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n " + ], + [ + "swap and ", + "pop" + ], + [ + "`value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens ", + "in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom" + ], + [ + "\"", + "@openzeppelin/contracts-upgradeable/" + ], + [ + "(", + "n" + ], + [ + ")", + ");\\n\\n " + ], + [ + ".", + "current" + ], + [ + "0", + "4" + ], + [ + "G", + "E" + ], + [ + "I", + "B" + ], + [ + "S", + "tuck" + ], + [ + "m", + "ade" + ], + [ + "to", + "sh" + ], + [ + "\\n * ", + "@param to " + ], + [ + "an ", + "account " + ], + [ + "ERC721", + "-" + ], + [ + "max", + "BuyAmount" + ], + [ + "token ", + "already minted" + ], + [ + "balances", + ", " + ], + [ + "with ", + "https://" + ], + [ + "role", + ". " + ], + [ + "Int", + "o" + ], + [ + "star", + "ting" + ], + [ + ";\\n\\n/**\\n * @dev ", + "Interface " + ], + [ + "st ", + "if " + ], + [ + "grant", + "Role(role, account);\\n }\\n\\n /**\\n * @dev " + ], + [ + ", _", + "amount" + ], + [ + "(address owner", + ") internal view returns (uint256) {\\n return " + ], + [ + "(address owner", + ",address " + ], + [ + ");\\r\\n", + "\\r\\n /**\\r\\n * @dev " + ], + [ + "IC", + "IENT" + ], + [ + ");\\n\\n // ", + "Overflows are " + ], + [ + "we", + "b3" + ], + [ + "being ", + "zero, " + ], + [ + "restr", + "ic" + ], + [ + "allowance for ", + "`spender` based on " + ], + [ + "make ", + "sure " + ], + [ + "mapping(address => uint256", + ") public " + ], + [ + "quantity ", + "== 0) revert Mint" + ], + [ + "Remo", + "ve " + ], + [ + ",uint256 ", + "value" + ], + [ + "Transfer ", + "Delay enabled" + ], + [ + "should", + "n't " + ], + [ + "dstRep", + "Num" + ], + [ + ");\\n }", + "\\n\\n" + ], + [ + "`owner` s ", + "allowance for `spender` based on " + ], + [ + "RRRR", + "RRRR" + ], + [ + "size := ", + "extcodesize" + ], + [ + ") |", + " (" + ], + [ + "Bit", + "Map" + ], + [ + "(address(0), to, startTokenId, quantity", + ");\\n\\n // Overflows are " + ], + [ + "\\tu", + "int256 " + ], + [ + "r := ", + "shr(" + ], + [ + "_verifyCallResult", + "(success, returndata, errorMessage" + ], + [ + "spent ", + "`amount" + ], + [ + "Updates ", + "`owner` s allowance for `spender` based on " + ], + [ + "receiver ", + "interface" + ], + [ + "remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * ", + "reverting " + ], + [ + "% total supply", + ".\"" + ], + [ + "UFF", + "ICIENT" + ], + [ + "oll", + "ar" + ], + [ + "with a division by zero ", + "flag.\\n *\\n * _Available since v3.4._\\n */\\n function try" + ], + [ + "func", + "-name-mixedcase" + ], + [ + "\\n }\\n }\\n\\n /**\\n * @dev ", + "Returns an `" + ], + [ + "_transfer:: ", + "Transfer Delay enabled" + ], + [ + ") internal virtual {\\n require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(to != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, amount);\\n\\n uint256 fromBalance = _balances[from];\\n require(fromBalance ", + ">= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n unchecked {\\n _balances[from] = fromBalance - amount" + ], + [ + "quantity == 0) revert Mint", + "ZeroQuantity" + ], + [ + "_transfer:: Transfer Delay enabled", + ". " + ], + [ + "(", + "uint8 " + ], + [ + "T", + "OTAL" + ], + [ + "\\n * ", + "half order, and the `v` value to be either 27 or 28" + ], + [ + "\\n * ", + "this is by receiving a hash of the original message (which may " + ], + [ + "st", + "ETH" + ], + [ + "Address", + "." + ], + [ + "value ", + "in the " + ], + [ + "contract ", + "from " + ], + [ + "up", + "lic" + ], + [ + ");\\n }\\n\\n /**\\n * @dev ", + "Overload of {ECDSA-recover" + ], + [ + "IP", + "ool" + ], + [ + "last", + "value" + ], + [ + ";\\n }\\n\\n /**\\n * @dev See {", + "IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual " + ], + [ + "update", + "Max" + ], + [ + "the\\n * ", + "verification to be secure: it is possible to craft signatures " + ], + [ + "De", + "p" + ], + [ + "renounce", + "Role(bytes32 role, address account" + ], + [ + "permit", + "(\\n address owner,\\n address spender" + ], + [ + "_marketing", + "Wallet" + ], + [ + "high", + "er than " + ], + [ + "\\n */\\nabstract contract ", + "ERC20" + ], + [ + "over ", + "a " + ], + [ + ".\\n *\\n * IMPORTANT: ", + "`hash` _must_ be the result of a hash operation for " + ], + [ + "mapping (address => ", + "bool" + ], + [ + "ite", + "List" + ], + [ + "with\\n * `", + "signature" + ], + [ + "enable", + "Trading" + ], + [ + "that\\n * ", + "recover to arbitrary addresses for non-hashed data. A safe way to ensure" + ], + [ + "_base", + "TokenURI" + ], + [ + "ERC721AQueryable", + "-" + ], + [ + "emergen", + "cy " + ], + [ + "fill", + "Random" + ], + [ + "Comm", + "on" + ], + [ + "String operations.\\n */\\nlibrary Strings {\\n bytes16 private constant _", + "HEX_SYMBOLS = \\\"0123456789abcdef" + ], + [ + "\"// SPDX-License-Identifier: MIT\\npragma solidity 0.6.", + "11" + ], + [ + "currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n unchecked {\\n ", + "_approve(owner, spender, currentAllowance - subtractedValue);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves `amount` of tokens from " + ], + [ + "safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes calldata data", + "\\n " + ], + [ + ".\\n *\\n * The `", + "ecrecover` EVM opcode allows for malleable (non-unique) signatures" + ], + [ + " to `recipient", + "`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function " + ], + [ + "Ste", + "p" + ], + [ + "downcasted) {\\n ", + "downcasted = int" + ], + [ + " bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted ", + "int" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata", + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\"" + ], + [ + "overhead", + " for " + ], + [ + "Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {}\\n\\n /**\\n * @dev Hook that is called after any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * has been transferred to `to`.\\n * - when `from` is zero, `amount` tokens have been minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n ", + ") internal virtual {}\\n}\\n\"" + ], + [ + ":\\n * ", + "this function rejects them by requiring the `s` value to be in the lower" + ], + [ + "Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721", + " is IERC165 {\\n /**\\n * @dev " + ], + [ + "address that signed a hashed message (`hash`) ", + "with\\n * `signature" + ], + [ + "otherwise\\n * ", + "be too long), and then calling {toEthSignedMessageHash} on it" + ], + [ + "address can then be used for verification purposes", + ".\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures" + ], + [ + "to` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address to, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _transfer(owner, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n ", + "_approve(owner, spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``from``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom" + ], + [ + "Updates `owner` s allowance for `spender` based on ", + "spent `amount" + ], + [ + "\\n * half order, and the `v` value to be either 27 or 28", + ".\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for " + ], + [ + "\\n * this is by receiving a hash of the original message (which may ", + "otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it" + ], + [ + "the\\n * verification to be secure: it is possible to craft signatures ", + "that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure" + ], + [ + ":\\n * this function rejects them by requiring the `s` value to be in the lower", + "\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for " + ], + [ + "address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures", + ":\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for " + ], + [ + "the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure", + "\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it" + ], + [ + "address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for ", + "the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it" + ], + [ + "(", + "@" + ], + [ + "2", + ";\\n }\\n if (value >> " + ], + [ + "4", + ";\\n result += " + ], + [ + "4", + ";\\n }\\n if (value >> " + ], + [ + "8", + ";\\n result += " + ], + [ + "8", + ";\\n }\\n if (value >> " + ], + [ + "B", + "al" + ], + [ + "M", + "is" + ], + [ + "t", + "s" + ], + [ + "\\n ", + "pure" + ], + [ + "address", + "Data" + ], + [ + "\\\"", + ",\\n " + ], + [ + "32", + " > 0) {\\n value >>= " + ], + [ + "set", + "_" + ], + [ + "\\n * - ", + "with https://" + ], + [ + "16", + ";\\n }\\n if (value >> " + ], + [ + "16", + " > 0) {\\n value >>= " + ], + [ + "(uint256 ", + "indexed " + ], + [ + "token ", + "g" + ], + [ + " is ", + "also " + ], + [ + "pay", + "ees" + ], + [ + ";\\n ", + "uint256 " + ], + [ + "64", + " > 0) {\\n value >>= " + ], + [ + " == ", + "owner || " + ], + [ + "_S", + "UB" + ], + [ + "UniswapV2", + "Library." + ], + [ + "gen", + "esis" + ], + [ + "128", + ";\\n result += " + ], + [ + ";\\n\\n ", + "if (" + ], + [ + "uint8 ", + "private constant _" + ], + [ + "key", + "Index" + ], + [ + "swapExactTokensFor", + "Tokens" + ], + [ + "if (!", + "_is" + ], + [ + "tokenURI", + "(uint256 tokenId) public view virtual override returns (" + ], + [ + "\"Address: ", + "call to non-contract\"" + ], + [ + "comp", + "romis" + ], + [ + "ethFor", + "Marketing" + ], + [ + "rele", + "v" + ], + [ + " > 0) {\\n value >>= ", + "128;\\n result += " + ], + [ + "getAmount", + "In" + ], + [ + "Im", + "mut" + ], + [ + "\\u003c", + "= " + ], + [ + ")\\r\\n ", + "external" + ], + [ + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function ", + "log2" + ], + [ + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function ", + "log10" + ], + [ + "_redis", + "FeeOnBuy" + ], + [ + " > 0) {\\n ", + "result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base " + ], + [ + "js", + "on" + ], + [ + "Filter", + "Operator" + ], + [ + "bytes32 private ", + "immutable _" + ], + [ + "\\\",\\\"", + "type\\\":\\\"" + ], + [ + "Address for address", + ";\\n using " + ], + [ + ">> 128", + " > 0) {\\n value >>= 128;\\n result += " + ], + [ + "32;\\n result += ", + "32" + ], + [ + "64;\\n result += ", + "64" + ], + [ + "(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value ", + ">> 128 > 0) {\\n value >>= 128;\\n result += " + ], + [ + ".startTimestamp = ", + "uint64(" + ], + [ + "Wrappers over ", + "Solidity's " + ], + [ + "ERC721Metadata: URI ", + "query for nonexistent token" + ], + [ + "result < value ? 1 : 0", + ");\\n }\\n }\\n\\n /**\\n * @dev Return the log in base " + ], + [ + "`\\n // ", + "→ `" + ], + [ + "from, tokenId, _data", + ") returns (" + ], + [ + "experimental ", + "ABIEncoderV2" + ], + [ + "16 > 0) {\\n value >>= ", + "16;\\n result += " + ], + [ + "_SUB", + "SCRIPTION" + ], + [ + "#", + "eth_sign" + ], + [ + "(", + ") internal view returns (" + ], + [ + ".", + "'" + ], + [ + "W", + "ill " + ], + [ + "_", + "start" + ], + [ + "_", + "uri" + ], + [ + "s", + "napshot " + ], + [ + "}", + ")" + ], + [ + ") ", + "returns (bool) {\\n " + ], + [ + "\\r", + "\\n */\\r\\n" + ], + [ + "to ", + "provide " + ], + [ + "str", + "ategy" + ], + [ + " = ", + "3" + ], + [ + "contract", + "URI" + ], + [ + " to ", + "implement " + ], + [ + "(uint256 ", + "_projectId" + ], + [ + "token ", + "holder " + ], + [ + "msg.sender", + " != " + ], + [ + "Balanc", + "e(" + ], + [ + "name", + "\\\":\\\"" + ], + [ + "Mint", + "ZeroQuantity" + ], + [ + "\\n ", + "{\\n " + ], + [ + "Int", + "ernal" + ], + [ + ",\\n address ", + "tokenB" + ], + [ + "approval", + " to " + ], + [ + "De", + "posi" + ], + [ + ";\\n }\\n ", + "_afterTokenTransfers(address(0), to, startTokenId, quantity" + ], + [ + "} else {", + "\\n " + ], + [ + "_ADDRESS", + "_LENGTH" + ], + [ + "tokenA", + ",\\n address tokenB" + ], + [ + "inSwap", + "AndLiquify" + ], + [ + "delete ", + "_tokenApprovals[tokenId" + ], + [ + "way", + "s" + ], + [ + "solhint-disable-next-line ", + "max-line-length" + ], + [ + "Returns an ", + "Ethereum Signed Message" + ], + [ + "SafeERC20", + " for " + ], + [ + "increas", + "e the " + ], + [ + "How", + "ever" + ], + [ + "safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId", + ",\\n bytes memory _data\\n " + ], + [ + "efficient", + " " + ], + [ + "\"Address: insufficient ", + "balance for call" + ], + [ + "paused(", + "), \\\"" + ], + [ + "] -= ", + "1;\\n " + ], + [ + "(\\n address sender,\\n address recipient", + ",\\n uint256 amount\\n " + ], + [ + "nip", + "er" + ], + [ + "index out of bound", + "s" + ], + [ + ",uint256 nonce,uint256 ", + "deadline" + ], + [ + "PAUS", + "ER_ROLE" + ], + [ + "authorization", + "s" + ], + [ + "Processed", + "Index" + ], + [ + "global_", + "collateral_" + ], + [ + "to.isContract", + "()" + ], + [ + "Histor", + "y" + ], + [ + "c >= ", + "a" + ], + [ + ");\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value", + ");\\n}\\n\"" + ], + [ + "token/ERC20/ERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./", + "IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum." + ], + [ + "(", + ");\\n\\n // " + ], + [ + ")", + "`." + ], + [ + "E", + "rc" + ], + [ + "_", + "RAT" + ], + [ + "`", + ",\\n * " + ], + [ + "value ", + ">= " + ], + [ + ") public ", + "{\\n " + ], + [ + ";\\n }\\n\\n /**\\n * @dev ", + "Call" + ], + [ + "bool ", + "is" + ], + [ + "bool ", + "whether " + ], + [ + "tokens", + "Into" + ], + [ + "to, ", + "uint value" + ], + [ + "dead", + "Address" + ], + [ + "Tim", + "es" + ], + [ + "18", + "20" + ], + [ + ".\\n * ", + "Use " + ], + [ + " {\\n ", + "enum " + ], + [ + "St", + "ate " + ], + [ + "proof", + "Element" + ], + [ + ") internal view virtual ", + "returns (bool) {\\n " + ], + [ + "OO", + "L" + ], + [ + "(value", + ") + " + ], + [ + "claim", + " " + ], + [ + "@@@@@@@@@@@@@@@@", + "@@@@@@@@" + ], + [ + "amount1", + "In" + ], + [ + "amount0", + "In" + ], + [ + "_P", + "RECISION" + ], + [ + " not ", + "being zero, " + ], + [ + "Bytes32", + "Set storage set, bytes32 value" + ], + [ + "correspond", + "ing to the " + ], + [ + "set._inner, ", + "value" + ], + [ + "compu", + "ted " + ], + [ + ", uint amount", + "B" + ], + [ + "\"Address: low-level ", + "call with value failed" + ], + [ + "\"Address: low-level ", + "call failed\"" + ], + [ + "].add(", + "amount);\\n emit Transfer" + ], + [ + "Gas ", + "optimization" + ], + [ + "These ", + "functions " + ], + [ + "contract that ", + "wants to " + ], + [ + "uint amountA", + ", uint amountB" + ], + [ + "();\\n\\n _beforeTokenTransfers", + "(address(0), to, startTokenId, quantity);\\n\\n // Overflows are " + ], + [ + "https://github.com/OpenZeppelin/openzeppelin-contracts/", + "pull/" + ], + [ + "benefit ", + "is lo" + ], + [ + "ERC721 token ", + "receiver interface" + ], + [ + "TokenGated", + "Drop" + ], + [ + " {\\n /**\\n * @dev Emitted when ", + "`value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom" + ], + [ + "compa", + "ti" + ], + [ + "% or less", + "\"" + ], + [ + "Cy", + "cle" + ], + [ + "per block allowed", + ".\"" + ], + [ + "tokenId.toString", + "())" + ], + [ + "(account, address(0), amount);\\n\\n _afterTokenTransfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(\\n address owner,\\n address spender,\\n uint256 amount\\n ", + ") internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev " + ], + [ + ": this is ", + "cheaper than " + ], + [ + "_QU", + "ANT" + ], + [ + "} that receives the `v", + "`,\\n * `" + ], + [ + "startTokenId = _currentIndex", + ";\\n if (" + ], + [ + "(address owner,address ", + "spender" + ], + [ + " is also ", + "test" + ], + [ + "\"Address: insufficient balance for call", + "\"" + ], + [ + " not being zero, ", + "but " + ], + [ + "\"Address: low-level call with value failed", + "\"" + ], + [ + "Gas optimization", + ": this is cheaper than " + ], + [ + "contract that wants to ", + "support " + ], + [ + "benefit is lo", + "st if " + ], + [ + "} that receives the `v`,\\n * `", + "r` and `s` signature fields separately" + ], + [ + "(", + "30" + ], + [ + ")", + "`.\\n */\\n function _" + ], + [ + "b", + "'" + ], + [ + "v", + "est" + ], + [ + "v", + "s` " + ], + [ + "{", + "\\n // " + ], + [ + "re", + "comm" + ], + [ + "re", + "lying " + ], + [ + "al", + "e " + ], + [ + "to", + "TypedData" + ], + [ + ", ", + "bytes memory data" + ], + [ + "un", + "safe" + ], + [ + "Token", + "Receiver" + ], + [ + "spender", + ",\\n uint256 value" + ], + [ + "for ", + "contracts " + ], + [ + "rec", + "ord " + ], + [ + "pro", + "xi" + ], + [ + "burn", + "ed (" + ], + [ + "(\\n address ", + "tokenA,\\n address tokenB" + ], + [ + "Pro", + "pos" + ], + [ + "AT", + "A " + ], + [ + "s to ", + "a " + ], + [ + "}.", + "\\r\\n *\\r\\n * " + ], + [ + "ren", + " to implement " + ], + [ + "sta", + "ticcall" + ], + [ + "string,", + "string" + ], + [ + "mar", + "y " + ], + [ + "` is zero, ", + "``from``'s " + ], + [ + "Returns a ", + "token ID " + ], + [ + "35", + "7" + ], + [ + "Befo", + "re " + ], + [ + "allows ", + "child" + ], + [ + "size ", + "> 0" + ], + [ + "Interface ", + "for any " + ], + [ + "RecoverError.", + "NoError" + ], + [ + "along ", + "with {" + ], + [ + "approved for ", + "all" + ], + [ + "(string ", + "calldata " + ], + [ + "break", + "s " + ], + [ + "access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _transferOwnership(_msgSender()", + ");\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev " + ], + [ + "s\\n * ", + "from " + ], + [ + "`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this ", + "token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function " + ], + [ + "token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20", + " {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom" + ], + [ + "at a given ", + "`index` " + ], + [ + "0.9", + ".0" + ], + [ + "short-", + "signature fields separately" + ], + [ + "Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev ", + "Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to" + ], + [ + "#eth_sign", + "[`eth_sign" + ], + [ + ".\\n * Use ", + "along with {" + ], + [ + "Gas optimization: this is cheaper than ", + "requiring " + ], + [ + "vs` ", + "short-signature fields separately" + ], + [ + "toTypedData", + "Hash" + ], + [ + "allows child", + "ren to implement " + ], + [ + "Interface for any ", + "contract that wants to support " + ], + [ + "\"", + "M" + ], + [ + "(", + "pair" + ], + [ + "G", + "nos" + ], + [ + "K", + "ind" + ], + [ + "U", + "pper" + ], + [ + "_", + "functionCallWithValue" + ], + [ + "g", + "row" + ], + [ + "r", + "pc" + ], + [ + "function", + "\\n * " + ], + [ + "is", + "Points" + ], + [ + "ed ", + "in the " + ], + [ + ");\\n ", + "_owner = " + ], + [ + "(address ", + "tokenA, address tokenB" + ], + [ + "new", + "Weight" + ], + [ + "add", + "ing" + ], + [ + "able ", + "only " + ], + [ + "token ", + "was " + ], + [ + "eth", + "Received" + ], + [ + "pay", + "ee" + ], + [ + "id", + "s, " + ], + [ + "utils/", + "Counters" + ], + [ + "\\n\\t", + "function " + ], + [ + "rol", + "es" + ], + [ + ") private ", + "_" + ], + [ + ";\\n\\n/**\\n * @dev ", + "Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * " + ], + [ + "must be ", + "less than " + ], + [ + " {\\n ", + "// " + ], + [ + "uint amount", + "ETH" + ], + [ + "_t", + "reasury" + ], + [ + "er than ", + "the " + ], + [ + "Mo", + "st" + ], + [ + "pool", + "." + ], + [ + "\\n ", + "\\\"" + ], + [ + "39", + "f" + ], + [ + "Uint", + "ToAddress" + ], + [ + "Permit", + "(address owner,address spender" + ], + [ + "Supply ", + "= " + ], + [ + "the caller ", + "must be " + ], + [ + ",\\n bytes32 ", + "root" + ], + [ + ")\\n external", + "\\n returns (" + ], + [ + "high", + "ly " + ], + [ + "ASCII", + " " + ], + [ + "bas", + "is point" + ], + [ + "target ", + "address that will receive the " + ], + [ + "[from", + "][" + ], + [ + "do ", + "not " + ], + [ + "IERC", + "1155" + ], + [ + "utils/introspection/ERC165", + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./" + ], + [ + "taken", + " " + ], + [ + "_operatorApproval", + "s[" + ], + [ + ");\\n }", + "\\n " + ], + [ + "_fee", + "Denominator" + ], + [ + "copy ", + "the " + ], + [ + "aver", + "age of " + ], + [ + "\\n mapping(uint256 => ", + "uint256) private " + ], + [ + ".\\r\\n *\\r\\n * Requirements:\\r\\n *\\r", + "\\n * - " + ], + [ + ".\\n //", + "\\n // " + ], + [ + ",string ", + "version" + ], + [ + "(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes memory _data\\n ", + ") private returns (bool) {\\n " + ], + [ + "EVENT_SIGNATUR", + "E" + ], + [ + "Ag", + "ent" + ], + [ + "EIP712Domain(string name", + ",string version" + ], + [ + "liquidityPair", + "Balance" + ], + [ + "slo", + "t to " + ], + [ + "target address that will receive the ", + "tokens" + ], + [ + "\"", + "Swap amount cannot be " + ], + [ + ";", + "\\n " + ], + [ + "A", + "Y" + ], + [ + "A", + "s of " + ], + [ + "L", + "ower" + ], + [ + "}", + "\\n // " + ], + [ + " ", + "// " + ], + [ + "\\n ", + "}\\n " + ], + [ + "in", + "al" + ], + [ + ", ", + "if " + ], + [ + "anc", + "el" + ], + [ + "\\r", + "\\n * - " + ], + [ + "ip", + "h" + ], + [ + ".s", + "lot" + ], + [ + "account", + "s to " + ], + [ + "ERC20", + "Detailed" + ], + [ + ". ", + "By " + ], + [ + "} ", + "while (" + ], + [ + "\\r\\n", + "* " + ], + [ + "by ", + "`operator" + ], + [ + ") external ", + "payable " + ], + [ + ") external ", + "returns(" + ], + [ + "ff", + "c" + ], + [ + "operator", + " is " + ], + [ + "] ", + "== " + ], + [ + "ard", + "inal" + ], + [ + "bytes32 ", + "s" + ], + [ + "openzeppelin", + "/" + ], + [ + "uti", + "lities " + ], + [ + ".\\n */\\n function _", + "total" + ], + [ + "path", + "[" + ], + [ + "in the ", + "Solidity " + ], + [ + "LE", + "D" + ], + [ + ")\\n ", + "}\\n return " + ], + [ + "int256", + " b" + ], + [ + ") {\\n ", + "// " + ], + [ + "setApprovalForAll", + "}.\\n */\\n function " + ], + [ + "delegat", + "es " + ], + [ + "minted ", + "(`" + ], + [ + ") {\\r\\n ", + "require(" + ], + [ + "decre", + "ased" + ], + [ + "stak", + "e " + ], + [ + "\\n _", + "revert(" + ], + [ + "() internal view virtual returns (", + "uint256) {\\n return " + ], + [ + "rel", + "ay" + ], + [ + "optional ", + "data to send along with the call" + ], + [ + "Addition", + " " + ], + [ + "arithme", + "tic operation" + ], + [ + ".code.length", + " > 0" + ], + [ + "missing ", + "in the Solidity " + ], + [ + "(address target, bytes memory data) internal returns (bytes memory) {\\n return ", + "functionCall(target, data, \\\"Address: low-level " + ], + [ + "partic", + "ular " + ], + [ + "{\\n return ", + "super._" + ], + [ + "math ", + "utilities " + ], + [ + "Internal function to ", + "invoke {IERC721Receiver-onERC721Received} on a target " + ], + [ + "_balances[to] += 1;\\n ", + "_owners[tokenId] = to;\\n\\n emit Transfer" + ], + [ + ",\\r\\n address to,\\r\\n ", + "uint deadline" + ], + [ + " to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function ", + "transfer(address recipient, uint256 amount" + ], + [ + "approval to ", + "current owner" + ], + [ + "bool whether ", + "the call correctly returned the expected magic value" + ], + [ + "minted (`", + "_mint" + ], + [ + "missing in the Solidity ", + "language" + ], + [ + "math utilities ", + "missing in the Solidity language" + ], + [ + "\"", + "src/" + ], + [ + "(", + "'" + ], + [ + ".", + "\\\"" + ], + [ + ".", + "wiki/" + ], + [ + "/", + "API" + ], + [ + ">", + "`\\n * - `" + ], + [ + "D", + "EC" + ], + [ + "W", + "E" + ], + [ + "`", + "\\n */\\n function " + ], + [ + "b", + "atch " + ], + [ + "d", + "4" + ], + [ + "d", + "ic" + ], + [ + "f", + "arm" + ], + [ + "r", + "y " + ], + [ + "{", + " " + ], + [ + "ac", + "ti" + ], + [ + "the ", + "fee " + ], + [ + "ent", + "ly" + ], + [ + "\\n\\n ", + "/// @dev " + ], + [ + "tor", + "age" + ], + [ + "account", + ".code.length > 0" + ], + [ + "an ", + "account's " + ], + [ + "Co", + "in" + ], + [ + ", uint256 ", + "p3) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(" + ], + [ + "with ", + "minimal " + ], + [ + " is ", + "already " + ], + [ + ", address ", + "p3) internal view {\\n\\t\\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature(\\\"log(" + ], + [ + "10", + " " + ], + [ + " b", + "ecause the " + ], + [ + "\\n *\\n * ", + "@dev " + ], + [ + "arke", + "ting " + ], + [ + "Tim", + "e(" + ], + [ + "balance ", + "= " + ], + [ + "transfer ", + "will be " + ], + [ + "██", + "╔" + ], + [ + "user", + "s" + ], + [ + "sto", + "red" + ], + [ + "Con", + "stant" + ], + [ + ", string memory ", + "p3) internal view {\\n\\t\\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature(\\\"log(" + ], + [ + ")\\\", p0, p1, p2", + "));\\n\\t\\tignored;\\n\\t}\\n\\n\\tfunction " + ], + [ + ".\\n ", + "mstore(" + ], + [ + ", bool ", + "p3) internal view {\\n\\t\\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature(\\\"log(" + ], + [ + "\\r\\n /**", + "\\r\\n * " + ], + [ + ", uint ", + "p3) internal view {\\n\\t\\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature(\\\"log(" + ], + [ + "mechanism", + " for " + ], + [ + "Address ", + "= _" + ], + [ + "has", + "Role(bytes32 role, address account" + ], + [ + "- 1", + "]." + ], + [ + ".\\n", + "\\n " + ], + [ + "_ownership", + "s" + ], + [ + "removeLiquidity", + "WithPermit" + ], + [ + "for a ", + "given " + ], + [ + "Payment", + "Address" + ], + [ + "merkle", + "Proof" + ], + [ + "ed. ", + "It " + ], + [ + "_tokenApprovals[tokenId", + "] = to" + ], + [ + "Hook that is called before ", + "any token transfer. This includes " + ], + [ + ")\\\", p0, p1, p2, p3));\\n\\t\\tignored;\\n\\t}\\n\\n\\tfunction ", + "log(address " + ], + [ + ");\\n\\n /**\\n * @notice ", + "Returns the " + ], + [ + "onlyAllowedOperator", + "(from" + ], + [ + "swapExactETHFor", + "Tokens" + ], + [ + "// solhint-disable-next-line ", + "func-name-mixedcase" + ], + [ + "address[] memory ", + "path" + ], + [ + "on-", + "rpc" + ], + [ + ")\\\", p0, p1, p2, p3));\\n\\t\\tignored;\\n\\t}\\n\\n\\tfunction log(", + "bool " + ], + [ + ")\\\", p0, p1, p2, p3));\\n\\t\\tignored;\\n\\t}\\n\\n\\tfunction log(", + "string memory " + ], + [ + "uint256 c = ", + "a * b" + ], + [ + "hashed", + "Name" + ], + [ + "getRoleAdmin", + "(bytes32 role" + ], + [ + "EL", + "D" + ], + [ + "js", + "on-rpc" + ], + [ + "Enabled = ", + "true" + ], + [ + "\\u0026", + "\\u0026" + ], + [ + "uniqu", + "e " + ], + [ + "Overload of {ECDSA-", + "tryRecover" + ], + [ + "Cor", + "rection" + ], + [ + "approve to ", + "caller" + ], + [ + "lipp", + "age " + ], + [ + "STOR", + "AGE" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// ERC721A Contracts v4.", + "2." + ], + [ + "projects[", + "_projectId" + ], + [ + "https://github.com/OpenZeppelin/openzeppelin-contracts/pull/", + "522" + ], + [ + ".wiki/", + "json-rpc" + ], + [ + ".wiki/json-rpc", + "/API" + ], + [ + "(", + "quantity" + ], + [ + "(", + "receiver, " + ], + [ + ",", + "\\n // " + ], + [ + "1", + "e" + ], + [ + "4", + "90" + ], + [ + "B", + "onus" + ], + [ + "O", + "TH" + ], + [ + "P", + "R" + ], + [ + "]", + "\\n *\\n * _Available since v4." + ], + [ + "_", + "target" + ], + [ + "d", + "b" + ], + [ + "\\n", + "pragma solidity ^0.8." + ], + [ + "e ", + "a " + ], + [ + "on", + "ce" + ], + [ + "\\n ", + "@param " + ], + [ + "de", + "b" + ], + [ + "address", + "[] " + ], + [ + "token", + "Holders" + ], + [ + "ex", + "it " + ], + [ + "ed ", + "== false" + ], + [ + "transfer", + ".\\n * " + ], + [ + "ERC20", + "Pausable" + ], + [ + "imp", + "l" + ], + [ + "from ", + "== " + ], + [ + "The ", + "number of " + ], + [ + ");\\n }\\n\\n /**\\n * @dev ", + "Convert" + ], + [ + "tokens ", + "list" + ], + [ + "pre", + "fix" + ], + [ + ";\\n ", + "uint8 " + ], + [ + "buy", + "OperationsFee" + ], + [ + "lat", + "form" + ], + [ + ");\\n ", + "uint256 " + ], + [ + "amounts", + "Out" + ], + [ + "initial", + "Supply" + ], + [ + "royal", + "ties " + ], + [ + "-= ", + "1" + ], + [ + "sqrt", + "Price" + ], + [ + "SeaDrop", + "(" + ], + [ + "vot", + "e " + ], + [ + "purpos", + "e is " + ], + [ + "reak", + "s " + ], + [ + "(uint256(", + "uint160" + ], + [ + "pop", + "(" + ], + [ + "paused ", + "= false" + ], + [ + "` is zero, `tokenId` will be ", + "burned by `from`.\\n * - `from` and `to` are never both zero.\\n */\\n function _" + ], + [ + "call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target", + ".staticcall" + ], + [ + "call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target", + ".call{value: value}" + ], + [ + "for {", + "permit" + ], + [ + "\\n //////////////////////////////////////////////////////////////*/", + "\\n\\n function " + ], + [ + "times", + ".\\n unchecked {\\n " + ], + [ + "necessari", + "ly " + ], + [ + "token/ERC721/IERC721", + ".sol\"" + ], + [ + "FixedPoint", + "." + ], + [ + "complex", + "ity" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `", + "quantity` must be greater than 0" + ], + [ + "`tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to", + "` is zero, `tokenId` will be burned by `from`.\\n * - `from` and `to` are never both zero.\\n */\\n function _" + ], + [ + "eloper", + "s " + ], + [ + ") {\\n require(isContract(target), \\\"Address: static ", + "call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall" + ], + [ + "Capp", + "ed" + ], + [ + "data bytes ", + "optional data to send along with the call" + ], + [ + ",uint256 value", + ",uint256 nonce,uint256 deadline" + ], + [ + "overhead for ", + "tokenomic" + ], + [ + "Updates `owner` s allowance for `spender` based on spent `amount", + "`.\\n *\\n * Does not update the allowance amount in case of infinite allowance.\\n * Revert if not enough allowance is available.\\n *\\n * Might emit an {Approval} event.\\n */\\n function _spendAllowance" + ], + [ + "token g", + "ated " + ], + [ + "Gnos", + "is " + ], + [ + "Permit(address owner,address spender", + ",uint256 value,uint256 nonce,uint256 deadline" + ], + [ + "with minimal ", + "overhead for tokenomic" + ], + [ + "(", + ");\\n }\\n\\n /**\\n * @dev " + ], + [ + "B", + "ank" + ], + [ + "F", + "D" + ], + [ + "P", + "ath" + ], + [ + "R", + "ight" + ], + [ + "_", + "|" + ], + [ + "_", + "newOwner" + ], + [ + "f", + "it" + ], + [ + "h", + "i" + ], + [ + "o", + "pp" + ], + [ + "nt", + "i" + ], + [ + "ing ", + "call" + ], + [ + "of ", + "tokens " + ], + [ + "\\n *", + "\\n * " + ], + [ + "account", + " to " + ], + [ + ". ", + "If the " + ], + [ + "ation", + " of `" + ], + [ + "total", + "ETHFee" + ], + [ + "Tokens", + "(" + ], + [ + "sign", + "ing " + ], + [ + "balanceOf", + "(" + ], + [ + "_A", + "L" + ], + [ + " b", + "ase " + ], + [ + "buy", + "BurnFee" + ], + [ + "(_", + "token" + ], + [ + "\\n * @dev ", + "Interface for any contract that wants to support " + ], + [ + "lock", + "ed " + ], + [ + "(address owner", + ", uint256 index" + ], + [ + ".sol)\\n\\npragma solidity ^0.8.0", + ";\\n\\n/**\\n * @title " + ], + [ + ".\\n ", + "mstore(0x" + ], + [ + "try", + "Add" + ], + [ + "try", + "Mul" + ], + [ + "`. ", + "This\\n * " + ], + [ + "decre", + "ase " + ], + [ + "inter", + "act " + ], + [ + ")\\\", p0, p1, p2, p3));\\n\\t}\\n\\n\\tfunction ", + "log(uint256 " + ], + [ + "50", + "1" + ], + [ + "Col", + "lateral " + ], + [ + "swapExactTokensFor", + "ETH" + ], + [ + "contracts.", + "\\n */\\ninterface " + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (", + "utils/introspection/ERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./" + ], + [ + "wallet", + "s" + ], + [ + "BP", + "T_" + ], + [ + "tick", + "et" + ], + [ + "add ", + "to the " + ], + [ + ", v", + "s" + ], + [ + "(data);\\n return ", + "_verifyCallResult(success, returndata, errorMessage" + ], + [ + "Second", + "s" + ], + [ + "token by either {approve} or {setApprovalForAll", + "}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n " + ], + [ + "` from ", + "`from" + ], + [ + ")\\\", p0, p1, p2, p3));\\n\\t\\tignored;\\n\\t}\\n\\n\\tfunction log(", + "uint " + ], + [ + "Sto", + "re the " + ], + [ + ";\\n }\\n\\n function ", + "set" + ], + [ + "safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ", + ") external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to" + ], + [ + "_AUX", + "_COMPLEMENT" + ], + [ + "los", + "ed" + ], + [ + "protect against ", + "flash loan " + ], + [ + "\"Must ", + "keep fees at " + ], + [ + "191", + ".\\n *\\n * See {recover}.\\n */\\n function " + ], + [ + "Scal", + "ingFactor" + ], + [ + "-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory", + ") {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall" + ], + [ + "compos", + "ability" + ], + [ + "HASHED_NAM", + "E" + ], + [ + "\\\");\\n require(isContract(target), \\\"Address: ", + "call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}" + ], + [ + "move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function ", + "safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to" + ], + [ + "https://eth", + ".wiki/json-rpc/API" + ], + [ + "`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function ", + "safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes calldata data\\n " + ], + [ + "token was ", + "burned" + ], + [ + "EIP712Domain(string name,string version", + ",uint256 chainId,address verifyingContract" + ], + [ + "Gnosis ", + "Safe" + ], + [ + "token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ", + ") external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId" + ], + [ + "protect against flash loan ", + "attack" + ], + [ + "'", + ", " + ], + [ + "6", + "e" + ], + [ + ";", + ";" + ], + [ + "Y", + "DF" + ], + [ + "_", + "/" + ], + [ + "_", + "sender" + ], + [ + "p", + "aid " + ], + [ + "s", + "im" + ], + [ + "v", + "3" + ], + [ + "th", + "ree " + ], + [ + ", ", + "can be " + ], + [ + "\\n * ", + "constructor" + ], + [ + "ed ", + "from " + ], + [ + ": ", + "transfer " + ], + [ + "call", + "datasize" + ], + [ + "from ", + "a contract" + ], + [ + "operator", + "Filter" + ], + [ + "}\\n", + "\\n " + ], + [ + ".sol\\\"", + ";\\n\\nimport \\\"./" + ], + [ + "safe", + "Approve" + ], + [ + "RE", + "C" + ], + [ + "(\\n address from,\\n address to,\\n uint256 ", + "amount\\n ) external returns (bool" + ], + [ + "Eth", + "er" + ], + [ + ")\\n ", + "{\\n require(" + ], + [ + "default", + "s to " + ], + [ + "_balances[account", + "] += amount" + ], + [ + "order", + "ing " + ], + [ + "ERC721 ", + "asset " + ], + [ + "enti", + "re" + ], + [ + "contracts ", + "is " + ], + [ + "\\\"\\n ", + ");\\n _" + ], + [ + "_TYP", + "E_HASH" + ], + [ + "access/Ownable", + ".sol\\\";\\nimport \\\"@openzeppelin/contracts/" + ], + [ + "removeLiquidity", + "ETHSupportingFeeOnTransferTokens" + ], + [ + "[from", + "] " + ], + [ + "easi", + "ly " + ], + [ + "9a", + "7" + ], + [ + "ayer", + "Zero" + ], + [ + "OF", + " " + ], + [ + "deposi", + "t " + ], + [ + "bptAmount", + "In" + ], + [ + "tokenOfOwnerByIndex", + "(address owner, uint256 index" + ], + [ + "\\r\\n *", + "/\\r\\n function " + ], + [ + "revert TransferToNonERC721ReceiverImplementer", + "();\\n " + ], + [ + "keccak256(abi.encodePacked(\\\"\\\\x19", + "Ethereum Signed Message:\\\\n" + ], + [ + ");\\n\\n // Clear approvals from the previous owner", + "\\n " + ], + [ + "INS", + "UFFICIENT" + ], + [ + "s.\\n ", + "uint64 " + ], + [ + "Returns `", + "true" + ], + [ + "Assum", + "es " + ], + [ + "with minimal overhead for tokenomic", + "s.\\n uint64 " + ], + [ + "\\n * @dev Interface for any contract that wants to support ", + "safeTransfer" + ], + [ + " ", + "\\u003e " + ], + [ + "/", + "address" + ], + [ + "4", + "0, " + ], + [ + "B", + "oost" + ], + [ + "X", + "128" + ], + [ + "i", + "e" + ], + [ + "y", + "s" + ], + [ + "al", + "i" + ], + [ + ", ", + "Ownable " + ], + [ + "dev", + "ic" + ], + [ + "Token", + "Supply" + ], + [ + "index", + "] = " + ], + [ + "new", + "Value" + ], + [ + "contract ", + "is not " + ], + [ + "Ex", + "ist" + ], + [ + "ff", + "ix" + ], + [ + "swap", + "ETHFor" + ], + [ + "Rol", + "e = " + ], + [ + "ed by ", + "calling " + ], + [ + "ERC165", + ", IERC165" + ], + [ + "` to ", + "protect against flash loan attack" + ], + [ + "can be ", + "circumvent" + ], + [ + "Ch", + "ar" + ], + [ + "interface ", + "is not " + ], + [ + ")\\n ", + "}\\n }\\n}\\n\"" + ], + [ + ".sol\\\";\\nimport \\\"", + "@openzeppelin/contracts-0.6/" + ], + [ + ", and ", + "does not provide " + ], + [ + ".\\n ", + "// See: " + ], + [ + "last", + "LpBurnTime" + ], + [ + "e.", + "\\n " + ], + [ + "_set", + "Implementation" + ], + [ + "It ", + "must " + ], + [ + "into ", + "the " + ], + [ + "Token ", + "ID" + ], + [ + "if (!", + "_" + ], + [ + "transferred to ", + "this contract " + ], + [ + "like ", + "Gnosis Safe" + ], + [ + "wallet", + "s\\n * " + ], + [ + ") == ", + "root" + ], + [ + "3._\\n */\\n function ", + "tryRecover" + ], + [ + ", b", + "reaks " + ], + [ + "assum", + "ed to be " + ], + [ + "You ", + "shouldn't " + ], + [ + "whitelist", + "ed" + ], + [ + "DOMAIN_SEPARATOR", + "() external view returns (bytes32" + ], + [ + "discourag", + "ed. It " + ], + [ + ".code.length", + ", which returns 0" + ], + [ + "s from ", + "contracts is " + ], + [ + "Sc", + "ri" + ], + [ + "`isContract", + "` to protect against flash loan attack" + ], + [ + "a function call", + "able only " + ], + [ + "in construction", + ", since the code is only stored at the end" + ], + [ + "currentAllowance = allowance(owner, spender", + ");\\n require(" + ], + [ + "percentage ", + "of the " + ], + [ + "Prevent", + "ing call" + ], + [ + "tokenByIndex", + "(uint256 index" + ], + [ + "reentrant ", + "call" + ], + [ + "c / ", + "a == b" + ], + [ + "callable ", + "if the " + ], + [ + "since it ", + "can be circumvent" + ], + [ + "produces hash ", + "corresponding to the " + ], + [ + "support for ", + "smart " + ], + [ + "Multipl", + "ication " + ], + [ + ") internal pure returns (address) {\\n (address recovered, RecoverError error) = ", + "tryRecover(hash" + ], + [ + ");\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev ", + "Overload of {ECDSA-tryRecover" + ], + [ + "_TRANSFER_", + "EVENT_SIGNATURE" + ], + [ + "token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory", + ");\\n}\\n\"" + ], + [ + "security ", + "since it can be circumvent" + ], + [ + "Max wallet exceed", + "ed\"" + ], + [ + "rely on ", + "`isContract` to protect against flash loan attack" + ], + [ + "SafeERC20 for ", + "IERC20" + ], + [ + "ERC721 token receiver interface", + "\\n * @dev Interface for any contract that wants to support safeTransfer" + ], + [ + "_QUANT", + "ITY" + ], + [ + "relying ", + "on " + ], + [ + "for contracts ", + "in construction, since the code is only stored at the end" + ], + [ + "breaks ", + "composability" + ], + [ + "s\\n * from ", + "ERC721 asset " + ], + [ + "highly ", + "discouraged. It " + ], + [ + "(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level ", + "call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call" + ], + [ + "// solhint-disable-next-line func-name-mixedcase", + "\\n function " + ], + [ + "]\\n *\\n * _Available since v4.", + "3._\\n */\\n function tryRecover" + ], + [ + "tokenHolders", + "Map" + ], + [ + "https://eth.wiki/json-rpc/API", + "#eth_sign[`eth_sign" + ], + [ + "/address", + ".code.length, which returns 0" + ], + [ + "ed by calling ", + "from a contract" + ], + [ + ", and does not provide ", + "security since it can be circumvent" + ], + [ + "like Gnosis Safe", + ", and does not provide security since it can be circumvent" + ], + [ + ", breaks ", + "support for smart " + ], + [ + "You shouldn't ", + "rely on `isContract` to protect against flash loan attack" + ], + [ + "s from contracts is ", + "highly discouraged. It " + ], + [ + "a function callable only ", + "when the " + ], + [ + "Preventing call", + "s from contracts is highly discouraged. It " + ], + [ + "ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfer", + "s\\n * from ERC721 asset " + ], + [ + "breaks composability", + ", breaks support for smart " + ], + [ + "like Gnosis Safe, and does not provide security since it can be circumvent", + "ed by calling from a contract" + ], + [ + "You shouldn't rely on `isContract` to protect against flash loan attack", + "s!" + ], + [ + "Preventing calls from contracts is highly discouraged. It ", + "breaks composability, breaks support for smart " + ], + [ + "-", + "byte " + ], + [ + "9", + "f" + ], + [ + "E", + "poch" + ], + [ + "R", + "ock" + ], + [ + "_", + "n" + ], + [ + "k", + "ind " + ], + [ + "l", + "em" + ], + [ + "r", + "al" + ], + [ + "====", + "\\n *\\n * " + ], + [ + "dev", + "Fee" + ], + [ + "acc", + "r" + ], + [ + ".\\n *\\n * ", + "It must " + ], + [ + "return ", + "its " + ], + [ + "if ", + "they are " + ], + [ + "} ", + "`tokenId` token is " + ], + [ + " to ", + "confirm" + ], + [ + "recipient", + ", the " + ], + [ + "max", + "SellAmount" + ], + [ + "token ", + "holder" + ], + [ + "current", + "Delegate" + ], + [ + "id", + "x" + ], + [ + "IN", + "D" + ], + [ + "IERC721", + "} `tokenId` token is " + ], + [ + "\\n // ", + "for contracts in construction, since the code is only stored at the end" + ], + [ + "`, ", + "this function is " + ], + [ + "If ", + "any other " + ], + [ + ".\\n * ", + "====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize" + ], + [ + ");\\n }\\n\\n function ", + "$" + ], + [ + "_token", + "Owner" + ], + [ + "_token", + "RoyaltyInfo" + ], + [ + "an {", + "IERC721} `tokenId` token is " + ], + [ + "ed in ", + "Solidity " + ], + [ + ".\\n *\\n * ", + "The " + ], + [ + "\\n *\\n * ", + "Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart " + ], + [ + "`owner", + "`.\\n */\\n function _" + ], + [ + ";\\r\\n ", + "}\\r\\n " + ], + [ + "slot", + "\\n }\\n }\\n\\n /**\\n * @dev Returns an `" + ], + [ + "selector", + " can be " + ], + [ + "selector", + " to confirm" + ], + [ + "Solidity ", + "selector to confirm" + ], + [ + "Implementation", + " of " + ], + [ + ";\\r\\n }\\r\\n", + " " + ], + [ + ";\\r\\n }\\r\\n", + "\\r\\n " + ], + [ + "Reg", + "iste" + ], + [ + "percent", + "age" + ], + [ + " in ", + "min" + ], + [ + "IERC721-", + "safeTransferFrom}\\n * " + ], + [ + "swapTokensFor", + "ExactTokens" + ], + [ + "By", + "Owner" + ], + [ + "make ", + "a function callable only when the " + ], + [ + "has been ", + "granted `role" + ], + [ + "value is ", + "returned " + ], + [ + "\"@openzeppelin/contracts/utils/", + "cryptography/" + ], + [ + "\\r\\n\\r\\n", + "pragma solidity ^0.8.0;\\r\\n\\r\\n" + ], + [ + "ecrecover", + " " + ], + [ + " the token ", + "transfer.\\n * " + ], + [ + "via {", + "IERC721-safeTransferFrom}\\n * " + ], + [ + "called", + ".\\n *\\n * It must " + ], + [ + "`account` ", + "has been granted `role" + ], + [ + "Uniswap", + "Pair" + ], + [ + ".\\n *\\n * The ", + "selector can be " + ], + [ + "\\n return ", + "account.code.length > 0" + ], + [ + "reverted", + ".\\n *\\n * The selector can be " + ], + [ + ",,,,,,,,", + ",,,,,,,," + ], + [ + "borrow", + "er" + ], + [ + "[IMPORTANT]\\n * ====\\n * ", + "You shouldn't rely on `isContract` to protect against flash loan attacks!" + ], + [ + "hsi", + "Address" + ], + [ + "StorageSlot", + ".get" + ], + [ + "bytes4(", + "keccak256('" + ], + [ + ".onERC721Received.selector", + "`.\\n */\\n function " + ], + [ + "constructor execution.\\n", + "\\n return account.code.length > 0" + ], + [ + "Ea", + "D" + ], + [ + "a g", + "ood " + ], + [ + "obtain", + "ed in Solidity " + ], + [ + " been granted `role`, emits a {RoleRevoked", + "} event" + ], + [ + "_default", + "RoyaltyInfo" + ], + [ + "or the ", + "interface is not " + ], + [ + "Whenever ", + "an {IERC721} `tokenId` token is " + ], + [ + "Modifier to ", + "make a function callable only when the " + ], + [ + "implemented by the ", + "recipient, the " + ], + [ + "\\n // of the ", + "constructor execution.\\n\\n return account.code.length > 0" + ], + [ + "transfer amount exceeds the maxTransactionAmount", + ".\"" + ], + [ + "contin", + "ue" + ], + [ + "_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: ", + "transfer caller is not owner nor approved" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall", + "(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call" + ], + [ + "magn", + "ified" + ], + [ + "` if ", + "`account` has been granted `role" + ], + [ + "Recovery", + "Mode" + ], + [ + "addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n uint256 ", + "currentAllowance = allowance(owner, spender);\\n require(" + ], + [ + "allowance(owner, spender) + ", + "addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n uint256 currentAllowance = allowance(owner, spender);\\n require(" + ], + [ + "permit(\\n address owner,\\n address spender", + ",\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n " + ], + [ + "to provide ", + "a " + ], + [ + "by `operator", + "` from `from" + ], + [ + "transfer will be ", + "reverted.\\n *\\n * The selector can be " + ], + [ + "contracts.\\n */\\ninterface ", + "IERC721Receiver" + ], + [ + "\\n * constructor", + ".\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize" + ], + [ + "Returns `true", + "` if `account` has been granted `role" + ], + [ + "transferred to this contract ", + "via {IERC721-safeTransferFrom}\\n * " + ], + [ + "wallets\\n * ", + "like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract" + ], + [ + "/address.code.length, which returns 0", + "\\n // for contracts in construction, since the code is only stored at the end" + ], + [ + "ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset ", + "contracts.\\n */\\ninterface IERC721Receiver" + ], + [ + "====\\n *\\n * ", + "[IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!" + ], + [ + "return its ", + "Solidity selector to confirm" + ], + [ + "`, this function is ", + "called.\\n *\\n * It must " + ], + [ + "If any other ", + "value is returned " + ], + [ + "\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart ", + "wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract" + ], + [ + " the token transfer.\\n * ", + "If any other value is returned " + ], + [ + "obtained in Solidity ", + "with `" + ], + [ + "or the interface is not ", + "implemented by the recipient, the " + ], + [ + "Whenever an {IERC721} `tokenId` token is ", + "transferred to this contract via {IERC721-safeTransferFrom}\\n * " + ], + [ + ";\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call", + "\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}" + ], + [ + "by `operator` from `from", + "`, this function is called.\\n *\\n * It must " + ], + [ + "transfer will be reverted.\\n *\\n * The selector can be ", + "obtained in Solidity with `" + ], + [ + "\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize", + "/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end" + ], + [ + "====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!", + "\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract" + ], + [ + "return its Solidity selector to confirm", + " the token transfer.\\n * If any other value is returned " + ], + [ + "or the interface is not implemented by the recipient, the ", + "transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `" + ], + [ + "Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * ", + "by `operator` from `from`, this function is called.\\n *\\n * It must " + ], + [ + "\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end", + "\\n // of the constructor execution.\\n\\n return account.code.length > 0" + ], + [ + "====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract", + "\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0" + ], + [ + "return its Solidity selector to confirm the token transfer.\\n * If any other value is returned ", + "or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `" + ], + [ + "Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must ", + "return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `" + ], + [ + ".", + "\\r\\n " + ], + [ + "0", + ", \\\"" + ], + [ + "Y", + "ield" + ], + [ + "c", + "b" + ], + [ + "d", + "EaD" + ], + [ + "v", + "ault " + ], + [ + "{", + "\\n " + ], + [ + "}", + ": " + ], + [ + "}", + ".\\n */\\n " + ], + [ + "return", + "datacopy" + ], + [ + ") ", + "is " + ], + [ + "is", + "Blacklisted" + ], + [ + "a ", + "transaction" + ], + [ + "To", + "o" + ], + [ + "as", + "s " + ], + [ + "/**", + "\\n@notice " + ], + [ + "wa", + "rn" + ], + [ + "bu", + "r" + ], + [ + "(address ", + "token" + ], + [ + "In", + "dic" + ], + [ + "ERC721", + "AS" + ], + [ + "at ", + "all" + ], + [ + "get", + "Owner" + ], + [ + "di", + "d " + ], + [ + "burn", + "Tokens" + ], + [ + "name", + "() public view virtual override returns (string memory) {\\n return _name" + ], + [ + "symbol", + "() public view virtual override returns (string memory) {\\n return _symbol" + ], + [ + "10", + ", following the selected rounding direction" + ], + [ + " b", + "ecause " + ], + [ + "buy", + "TotalFee" + ], + [ + "tax", + "FeeOnSell" + ], + [ + "base", + "TokenURI" + ], + [ + "uint amount", + "1" + ], + [ + "To ", + "change " + ], + [ + "admin", + ", use {" + ], + [ + "Col", + "lect" + ], + [ + "admin ", + "role that " + ], + [ + "] += ", + "amount;\\n " + ], + [ + "New", + " " + ], + [ + "sal", + "t" + ], + [ + ";\\n uint256 public ", + "constant " + ], + [ + "member", + "s" + ], + [ + "OperatorFilter", + "Registry " + ], + [ + "/* ", + "========" + ], + [ + "creator", + " " + ], + [ + "under", + "lying" + ], + [ + "ument", + "ation " + ], + [ + "(uint256 tokenId) public view virtual override returns (", + "address) {\\n " + ], + [ + "This function ", + "should only be called " + ], + [ + "compil", + "er's " + ], + [ + "uint256[] memory", + ") {\\n " + ], + [ + "safeTransferFrom} ", + "whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this " + ], + [ + "isApprovedForAll(owner, ", + "_msgSender())" + ], + [ + "due ", + "to " + ], + [ + "`.\\n *\\n * WARNING: Usage of this method is discouraged, use {", + "safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this " + ], + [ + "ECDSA.", + "recover" + ], + [ + "QuantityExceeds", + "Limit" + ], + [ + "INon", + "Fungible" + ], + [ + "OTH", + "ER" + ], + [ + "swapETHFor", + "ExactTokens" + ], + [ + "admin role that ", + "control" + ], + [ + "This function should only be called ", + "from the " + ], + [ + "\"", + "The " + ], + [ + ")", + "\\n // " + ], + [ + "*", + "/\\n " + ], + [ + "F", + "B" + ], + [ + "_", + "address " + ], + [ + "_", + "length" + ], + [ + "_", + "to, " + ], + [ + "b", + " ? a : b;\\n }\\n\\n /**\\n * @dev Returns the " + ], + [ + "d", + "one " + ], + [ + "n", + "est" + ], + [ + "to", + "re the " + ], + [ + "an", + "al" + ], + [ + ", ", + "owner" + ], + [ + "256", + " bits" + ], + [ + "ing ", + "account had" + ], + [ + "mint", + "ing\\n * " + ], + [ + "approve", + "}.\\n */\\n function " + ], + [ + ", \\\"", + "SafeERC20: " + ], + [ + "per", + "mit " + ], + [ + "bytes32 ", + "private constant _" + ], + [ + ".\\n */\\n function _", + "safeMint(\\n address to" + ], + [ + "sell", + "BurnFee" + ], + [ + ") internal virtual ", + "{\\r\\n require(" + ], + [ + "Pay", + "er" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - ", + "the caller must be " + ], + [ + "last", + "Manual" + ], + [ + "out", + "com" + ], + [ + ".\\n ", + "let " + ], + [ + "`owner", + "`'s " + ], + [ + "mis", + "plac" + ], + [ + ";\\r\\n ", + "}\\r\\n\\r\\n " + ], + [ + "version", + " of {" + ], + [ + "percent", + "For" + ], + [ + "712", + " " + ], + [ + "e is ", + "misplac" + ], + [ + "(_msgSender(), ", + "operator, approved" + ], + [ + "their ", + "privileg" + ], + [ + "tokenURI", + "}.\\n */\\n function " + ], + [ + "Tokens ", + "array" + ], + [ + "46", + "68" + ], + [ + "If the call", + "ing account had" + ], + [ + "................", + "........" + ], + [ + "vot", + "e" + ], + [ + "via {", + "grantRole} and {revokeRole" + ], + [ + "such as ", + "when a " + ], + [ + "ed (", + "such as when a " + ], + [ + "return\\n ", + "interfaceId == type(" + ], + [ + "caller must own the token or be an approved operator", + ".\\n */\\n error " + ], + [ + "\\n ) internal pure returns (", + "bool) {\\n return " + ], + [ + "decl", + "a" + ], + [ + "s `role", + "`. See {" + ], + [ + "interes", + "t " + ], + [ + "optional metadata ", + "extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721" + ], + [ + "getAmounts", + "Out" + ], + [ + "`account`.\\n *\\n * If `account` had", + " been granted `role`, emits a {RoleRevoked} event" + ], + [ + "Fees[", + "2" + ], + [ + "\\n //", + " " + ], + [ + ". This includes ", + "minting.\\n * And also called " + ], + [ + "removeLiquidityETHWithPermit", + "SupportingFeeOnTransferTokens" + ], + [ + "often ", + "managed " + ], + [ + "recipient` cannot be the zero address", + ".\\n * - the caller must have a balance of at least `amount`.\\n */\\n function " + ], + [ + "Roles are ", + "often managed " + ], + [ + "lose ", + "their privileg" + ], + [ + ".l", + "ayout" + ], + [ + "observ", + "ation" + ], + [ + "trusted ", + "devic" + ], + [ + "fur", + "ther " + ], + [ + "utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev ", + "Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to" + ], + [ + ") public virtual override returns (bool) {\\n address spender = _msgSender();\\n _spendAllowance(from, spender, amount);\\n _transfer(from, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, ", + "allowance(owner, spender) + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n uint256 currentAllowance = allowance(owner, spender);\\n require(" + ], + [ + "size := extcodesize", + "(account" + ], + [ + "compromis", + "ed (such as when a " + ], + [ + "recomm", + "ended to " + ], + [ + "accounts to ", + "lose their privileg" + ], + [ + "mechanism for ", + "accounts to lose their privileg" + ], + [ + "purpose is ", + "to provide a " + ], + [ + "(uint256(uint160", + "(value))" + ], + [ + "if they are ", + "compromised (such as when a " + ], + [ + "}: ", + "this function" + ], + [ + "admin role that control", + "s `role`. See {" + ], + [ + "b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the ", + "smallest " + ], + [ + "via {grantRole} and {revokeRole", + "}: this function" + ], + [ + "optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721", + "Metadata is " + ], + [ + "Roles are often managed ", + "via {grantRole} and {revokeRole}: this function" + ], + [ + "trusted devic", + "e is misplac" + ], + [ + "purpose is to provide a ", + "mechanism for accounts to lose their privileg" + ], + [ + "if they are compromised (such as when a ", + "trusted device is misplac" + ], + [ + "admin role that controls `role`. See {", + "grantRole} " + ], + [ + "\"", + "_transfer:: Transfer Delay enabled. " + ], + [ + ")", + "\\r\\n " + ], + [ + ".", + "\\n\\n " + ], + [ + "B", + "AL" + ], + [ + "I", + "Router" + ], + [ + "_", + "tokens" + ], + [ + "_", + "register" + ], + [ + "`", + "SafeMath" + ], + [ + "e", + "B6" + ], + [ + "\\n ", + ") private view returns (" + ], + [ + "t ", + "& 0x" + ], + [ + "address", + "[](" + ], + [ + "im", + "in" + ], + [ + "le", + "f" + ], + [ + "if", + "f" + ], + [ + ";\\n ", + "seriesSum += " + ], + [ + "Address", + ".sol)\\n\\npragma solidity ^0.8." + ], + [ + "From", + "Fees" + ], + [ + ") public ", + "onlyOwner {\\n " + ], + [ + "0000", + "dEaD" + ], + [ + "up", + " to " + ], + [ + "burn", + "(uint256 amount" + ], + [ + "tokens ", + "will " + ], + [ + "Mint", + "ToZeroAddress" + ], + [ + "Op", + "tion" + ], + [ + "`to", + "` to " + ], + [ + ",\\n uint256 ", + "denominator" + ], + [ + "iz", + "ation " + ], + [ + "Liquidity", + "Pair" + ], + [ + "``", + "sender" + ], + [ + "Not", + "Initialized" + ], + [ + ";\\n\\nimport \\\"", + "@balancer-labs/v2-" + ], + [ + "storage ", + "slot" + ], + [ + "Exact", + "ETH" + ], + [ + "edi", + "tion " + ], + [ + "bool,", + "uint," + ], + [ + ", uint ", + "value" + ], + [ + "Reg", + "ister" + ], + [ + "e is ", + "the " + ], + [ + "swapTokensFor", + "ExactETH" + ], + [ + ")\\n ", + "} " + ], + [ + "ERC2981", + ": " + ], + [ + "interfaceId == type(", + "IERC721Metadata" + ], + [ + "calls to ", + "a " + ], + [ + "p0, address p1", + ", uint p2" + ], + [ + "p0, bool p1", + ", uint p2" + ], + [ + "p0, string memory p1", + ", uint p2" + ], + [ + "\\\\xe", + "5" + ], + [ + "directly ", + "or " + ], + [ + "_exists(tokenId", + "), \\\"" + ], + [ + "p0, uint p1", + ", address p2" + ], + [ + "p0, uint p1", + ", string memory p2" + ], + [ + "p0, uint p1", + ", bool p2" + ], + [ + "p0, uint p1", + ", uint p2" + ], + [ + "ERC721Enumerable", + ": " + ], + [ + "\\\\xe3\\\\x8", + "2" + ], + [ + "extra ", + "data " + ], + [ + "balanceOf}.\\n */\\n function ", + "balanceOf(address owner" + ], + [ + "OPERATOR_FILTER_REGISTRY", + "." + ], + [ + "(0, ", + "0, " + ], + [ + "set._values", + ".length" + ], + [ + "Revokes `role` from ", + "the calling account.\\n *\\n * " + ], + [ + "Revokes `role` from ", + "`account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event" + ], + [ + "(\\n address token", + ",\\n uint liquidity" + ], + [ + "_addTokenTo", + "OwnerEnumeration" + ], + [ + "isexemptfrom", + "maxTX" + ], + [ + "\\x", + "19" + ], + [ + "GSN", + " " + ], + [ + "verifies ", + "that a " + ], + [ + "Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are ", + "minted (`_mint" + ], + [ + "jo", + "in " + ], + [ + "sender != address(0), \\\"ERC20: ", + "transfer from the zero address\\\");\\n require(" + ], + [ + " ✓", + " ✓" + ], + [ + "setApprovalForAll}.\\n */\\n function ", + "setApprovalForAll(address operator, bool approved" + ], + [ + "math utilities missing in the Solidity language", + ".\\n */\\nlibrary " + ], + [ + ".layout", + "()." + ], + [ + "Address.sol)\\n\\npragma solidity ^0.8.", + "1" + ], + [ + "(\\n address token,\\n uint liquidity", + ",\\n uint amountTokenMin,\\n uint amountETHMin,\\n address to,\\n uint deadline" + ], + [ + "\"", + "H" + ], + [ + "'", + "a'" + ], + [ + "'", + "b'" + ], + [ + "2", + ")" + ], + [ + "3", + "b" + ], + [ + "V", + "E" + ], + [ + "a", + "7" + ], + [ + "b", + "ond" + ], + [ + "e", + "1" + ], + [ + "s", + "af" + ], + [ + "x", + ",\\n uint256 " + ], + [ + "ed", + ").\\n *\\n * " + ], + [ + "qu", + "ote" + ], + [ + ".\\n *", + "\\n * " + ], + [ + ": ", + "reentrant call" + ], + [ + "or ", + "equal" + ], + [ + "an ", + "element" + ], + [ + "value", + ";\\n }\\n\\n struct " + ], + [ + "Transfer", + "} event" + ], + [ + "In", + "centi" + ], + [ + ".sol", + "\\u0027" + ], + [ + "set", + "AutomatedMarketMakerPair" + ], + [ + "di", + "vide " + ], + [ + "imp", + "ro" + ], + [ + "sender", + "` cannot be the zero address.\\n * - `" + ], + [ + "(uint256 ", + "_amount" + ], + [ + "symbol", + "}.\\n */\\n function " + ], + [ + "import ", + "\\u0027" + ], + [ + "override ", + "returns (bool) {\\n " + ], + [ + "will ", + "revert " + ], + [ + " b", + ") + (" + ], + [ + "+ ", + "1" + ], + [ + "Min", + "er" + ], + [ + "Min", + ",\\r\\n " + ], + [ + "tax", + "FeeOnBuy" + ], + [ + "&&", + " to " + ], + [ + "has ", + "not " + ], + [ + "the owner", + " or " + ], + [ + "s are ", + "not " + ], + [ + "es[", + "i]" + ], + [ + "Initializ", + "e the " + ], + [ + ") internal virtual {\\n ", + "if (" + ], + [ + "Add", + "s the " + ], + [ + "AD", + "MIN" + ], + [ + "limit", + "ed" + ], + [ + "}.\\n *\\n * ", + "To change " + ], + [ + "OU", + "T_" + ], + [ + "[0", + "]" + ], + [ + "LP", + " " + ], + [ + "End", + "Time" + ], + [ + "abi.decode", + "(" + ], + [ + "(sender, recipient, amount", + ");\\n\\n uint256 " + ], + [ + "revokeRole", + "}.\\n *\\n * To change " + ], + [ + "reentranc", + "y-" + ], + [ + "-name", + "}.\\n */\\n function " + ], + [ + "Distribu", + "tion" + ], + [ + "call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target", + ".delegatecall" + ], + [ + "(data);\\n return verifyCallResult(success, returndata, errorMessage", + ");\\n }\\n\\n /**\\n * @dev Tool to " + ], + [ + "}\\n * event", + ".\\n *\\n * Requirements:\\n *\\n * - the caller must be " + ], + [ + "wrapp", + "ed" + ], + [ + "_setRoleAdmin", + "}.\\n */\\n function " + ], + [ + "{permit} ", + "method" + ], + [ + "es\\n * ", + "if they are compromised (such as when a trusted device is misplac" + ], + [ + "a role's ", + "admin, use {" + ], + [ + "one signed with the\\n * ", + "https://eth.wiki/json-rpc/API#eth_sign[`eth_sign" + ], + [ + "`]\\n * JSON-RPC method as part of EIP-", + "191.\\n *\\n * See {recover}.\\n */\\n function " + ], + [ + "nextTokenId = tokenId + ", + "1" + ], + [ + "and\\n * {", + "revokeRole}.\\n *\\n * To change " + ], + [ + "`sender` to `recipient` ", + "using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom" + ], + [ + " {\\n /**\\n * @dev Returns the amount of tokens ", + "in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account" + ], + [ + ") internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate ", + "call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.delegatecall" + ], + [ + "benefit is lost if ", + "'b'" + ], + [ + "Gas optimization: this is cheaper than requiring ", + "'a'" + ], + [ + "bool whether the call correctly returned the expected magic value", + "\\n */\\n function " + ], + [ + "opp", + "os" + ], + [ + "`. This\\n * ", + "produces hash corresponding to the " + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./", + "IERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165 is IERC165 {\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165).interfaceId;\\n }\\n}\\n\"" + ], + [ + "Returns `true` if `account` has been granted `role", + "`.\\n */\\n function " + ], + [ + "purpose is to provide a mechanism for accounts to lose their privileg", + "es\\n * if they are compromised (such as when a trusted device is misplac" + ], + [ + "admin role that controls `role`. See {grantRole} ", + "and\\n * {revokeRole}.\\n *\\n * To change " + ], + [ + "Revokes `role` from the calling account.\\n *\\n * ", + "Roles are often managed via {grantRole} and {revokeRole}: this function" + ], + [ + "sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(", + "recipient != address(0), \\\"ERC20: " + ], + [ + "ed).\\n *\\n * ", + "If the calling account had" + ], + [ + "(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to ", + "verifies that a " + ], + [ + "one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign", + "`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function " + ], + [ + "benefit is lost if 'b'", + " is also test" + ], + [ + "Gas optimization: this is cheaper than requiring 'a'", + " not being zero, but " + ], + [ + "`. This\\n * produces hash corresponding to the ", + "one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function " + ], + [ + "purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplac", + "ed).\\n *\\n * If the calling account had" + ], + [ + "`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function ", + "toEthSignedMessageHash" + ], + [ + " ", + "can " + ], + [ + "\"", + "Max wallet exceeded\"" + ], + [ + "P", + "ast" + ], + [ + "T", + "E" + ], + [ + "a", + "\\n * " + ], + [ + "m", + "er" + ], + [ + "uint256 ", + "currentAllowance = " + ], + [ + " = ", + "true" + ], + [ + "(address ", + "user" + ], + [ + "(address ", + "to, uint256 amount" + ], + [ + "Su", + "ffix" + ], + [ + "virtual ", + "returns (" + ], + [ + "For", + "ExtraData" + ], + [ + "Ownership", + "NotInitialized" + ], + [ + "transferFrom", + "}.\\n */\\n function " + ], + [ + "(_", + "to, " + ], + [ + "sell", + "TotalFee" + ], + [ + ".\\n */\\n ", + "constructor (" + ], + [ + ". This ", + "can be " + ], + [ + "}.\\n */\\n function ", + "ownerOf" + ], + [ + "}.\\n */\\n function ", + "getApproved" + ], + [ + "use", + "Nonce" + ], + [ + ";\\r\\n", + " }\\r\\n" + ], + [ + "\\n *\\n * ", + "Requirements:\\n *" + ], + [ + "tokensFor", + "Operations" + ], + [ + "count", + " " + ], + [ + ", uint ", + "liquidity" + ], + [ + " {\\n /**\\n * @dev ", + "Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `" + ], + [ + "ownerOf", + "}.\\n */\\n function ownerOf" + ], + [ + "xy", + "z" + ], + [ + "operation", + " is " + ], + [ + "wei", + "ght " + ], + [ + "royalty", + "." + ], + [ + "getApproved", + "}.\\n */\\n function getApproved" + ], + [ + ",\\n uint amount", + "OutMin" + ], + [ + "(address target, bytes memory data", + ", uint256 value" + ], + [ + "tokenId` token ", + "must be owned by `from`" + ], + [ + "kn", + "ow the " + ], + [ + "ERC2309", + "_QUANTITY" + ], + [ + "ERC2309", + "QuantityExceedsLimit" + ], + [ + "paramet", + "ers, " + ], + [ + ");\\n }\\n\\n /**\\n * @dev See {IERC721-", + "isApprovedForAll" + ], + [ + ");\\n }\\n\\n /**\\n * @dev See {IERC721-", + "getApproved}.\\n */\\n function getApproved" + ], + [ + "ven", + "ue" + ], + [ + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n ", + "require(b" + ], + [ + "01", + "ffc" + ], + [ + "\\n * @return ", + "bool whether the call correctly returned the expected magic value\\n */\\n function " + ], + [ + "zero.\\n */\\n function ", + "average" + ], + [ + "} event.\\n *\\n * Requirements:\\n *\\n * - `", + "sender` cannot be the zero address.\\n * - `" + ], + [ + "uniswap", + "/" + ], + [ + "_EXTRA_DATA", + "_COMPLEMENT" + ], + [ + "https://eips.ethereum.org/EIPS/eip-721", + "[ERC721" + ], + [ + "purch", + "ase" + ], + [ + "uint amountIn", + ",\\n uint amountOutMin" + ], + [ + "mload(add(signature", + ", 0x20" + ], + [ + "];\\n }\\n\\n /**\\n * @dev See {IERC721-", + "setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved" + ], + [ + "100000000", + "0" + ], + [ + " * _", + "expTable" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `", + "tokenId` token must be owned by `from`" + ], + [ + "redis", + "FeeOnSell" + ], + [ + "recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount", + "`.\\n */\\n function _transfer" + ], + [ + ";\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-", + "symbol}.\\n */\\n function " + ], + [ + "(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes", + "-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall" + ], + [ + "mload(add(signature, 0x", + "40" + ], + [ + ") / _", + "ONE" + ], + [ + "\\n * @param tokenId uint256 ID of the token", + " to be transferred" + ], + [ + "common", + "/" + ], + [ + "cost ", + "of " + ], + [ + "operate on ", + "`tokenId`" + ], + [ + "return _tokenApprovals[tokenId", + "];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved" + ], + [ + ".\\r\\n */", + "\\r\\n " + ], + [ + "from address representing the previous owner of the given token ID", + "\\n * @param to " + ], + [ + "a, ", + "int256 b" + ], + [ + "Only one ", + "purchase " + ], + [ + "-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ", + ") internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.delegatecall" + ], + [ + "effec", + "tivel" + ], + [ + "s := ", + "mload(add(signature, 0x40" + ], + [ + "MAX_MINT_", + "ERC2309_QUANTITY" + ], + [ + "state-", + "changing " + ], + [ + "ardinal", + "ity" + ], + [ + "Implementation of ", + "https://eips.ethereum.org/EIPS/eip-721[ERC721" + ], + [ + "ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721Receiver", + " {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `" + ], + [ + "ERC721AS", + "torage" + ], + [ + "did ", + "not " + ], + [ + "approve}.\\n */\\n function ", + "approve(address to, uint256 tokenId" + ], + [ + ") public virtual override returns (bool) {\\n address spender = _msgSender();\\n _spendAllowance(from, spender, amount);\\n _transfer(from, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, allowance(owner, spender) + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n uint256 currentAllowance = allowance(owner, spender);\\n require(", + "currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - subtractedValue);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves `amount` of tokens from " + ], + [ + "`to` to ", + "operate on `tokenId`" + ], + [ + "_setRoleAdmin}.\\n */\\n function ", + "getRoleAdmin(bytes32 role" + ], + [ + "Returns `true` if `account` has been granted `role`.\\n */\\n function ", + "hasRole(bytes32 role, address account" + ], + [ + "OwnershipNotInitialized", + "ForExtraData" + ], + [ + "01ffc", + "9a7" + ], + [ + "} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `", + "recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer" + ], + [ + "uint amountIn,\\n uint amountOutMin", + ",\\n address[] calldata path,\\n address to,\\n uint deadline" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`", + ".\\n *\\n * Emits a {Transfer} event.\\n */\\n function " + ], + [ + "from address representing the previous owner of the given token ID\\n * @param to ", + "target address that will receive the tokens" + ], + [ + "a, int256 b", + ") internal pure returns (int256" + ], + [ + "MAX_MINT_ERC2309_QUANTITY", + "_LIMIT" + ], + [ + "Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721", + "] " + ], + [ + "(", + ") {\\n require(" + ], + [ + "2", + ";\\n result += " + ], + [ + "G", + "lob" + ], + [ + "c", + "al" + ], + [ + "c", + "ess " + ], + [ + "\\n", + "/// " + ], + [ + "s ", + "!= " + ], + [ + ", ", + "value" + ], + [ + "ro", + "cket" + ], + [ + "function", + "s" + ], + [ + "end", + "Time" + ], + [ + "uint256 ", + "nextTokenId = tokenId + 1" + ], + [ + "\\n *", + " " + ], + [ + "\\n function ", + "_" + ], + [ + "tor", + "age " + ], + [ + "in ", + "order " + ], + [ + "(address ", + "delegatee" + ], + [ + "\\r\\n", + " " + ], + [ + ";\\n\\n ", + "mapping (address => " + ], + [ + "(\\n ", + "uint amountIn,\\n uint amountOutMin,\\n address[] calldata path,\\n address to,\\n uint deadline" + ], + [ + "@@@@", + "@@" + ], + [ + "implement", + "ing " + ], + [ + "`.", + "\\r\\n *\\r\\n * " + ], + [ + "returns (bool", + ")" + ], + [ + "exist", + "s(" + ], + [ + "fee", + "Rate" + ], + [ + "\"@openzeppelin/contracts/", + "token/ERC721/IERC721.sol\"" + ], + [ + "use", + "L" + ], + [ + "MA", + "N" + ], + [ + "E_", + "D" + ], + [ + "previous", + "ExtraData" + ], + [ + "gener", + "ation" + ], + [ + "access", + "or" + ], + [ + "string,", + "address" + ], + [ + "string,", + "bool" + ], + [ + "does", + "n't" + ], + [ + "cannot ", + "exceed " + ], + [ + "== 0", + ") revert " + ], + [ + "Ar", + "ray " + ], + [ + "prevOwnership", + ".addr" + ], + [ + "(\\n uint256 ", + "x,\\n uint256 " + ], + [ + "ReentrancyGuard", + ": reentrant call" + ], + [ + "request", + "ed " + ], + [ + "ptr", + ", " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Transfers ", + "`tokenId` from `from` to `to`" + ], + [ + "Snapshot", + "s" + ], + [ + "Red", + "emption" + ], + [ + "precisi", + "on " + ], + [ + "throw", + " " + ], + [ + "_rol", + "es[role].members[account" + ], + [ + "removed ", + "from " + ], + [ + "tak", + "es the " + ], + [ + "set._inner, bytes32", + "(uint256(uint160(value))" + ], + [ + "ayout", + ":" + ], + [ + "wra", + "p" + ], + [ + " ? a : b;\\n }\\n\\n /**\\n * @dev Returns the ", + "average of " + ], + [ + "recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount", + "`.\\n * - the caller must have allowance for " + ], + [ + "_move", + "Delegates" + ], + [ + "Whether ", + "the " + ], + [ + "Migr", + "ation" + ], + [ + "IVault", + "." + ], + [ + "IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, ", + "optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is " + ], + [ + ");\\n\\n /**\\n * @dev Revert ", + "with an error " + ], + [ + "low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason ", + "using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {" + ], + [ + "Library ", + "for " + ], + [ + "sender` and `", + "recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for " + ], + [ + "data bytes optional data to send along with the call", + "\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function " + ], + [ + "recommended to ", + "use " + ], + [ + "import \\u0027", + "./" + ], + [ + "-name}.\\n */\\n function ", + "name() public view virtual override returns (string memory) {\\n return _name" + ], + [ + "(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a ", + "low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {" + ], + [ + "from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens", + "\\n * @param tokenId uint256 ID of the token to be transferred" + ], + [ + "&", + " b) + (" + ], + [ + "2", + "e" + ], + [ + "7", + "4" + ], + [ + "S", + "ol" + ], + [ + "T", + "ake" + ], + [ + "V", + "1" + ], + [ + "_", + "router" + ], + [ + "_", + "dstChainId" + ], + [ + "d", + "uplic" + ], + [ + "f", + "rozen" + ], + [ + "p", + "erf" + ], + [ + "r", + "y" + ], + [ + "u", + "i" + ], + [ + "in", + "directly" + ], + [ + ", ", + "and" + ], + [ + "token", + "0 " + ], + [ + "is", + "\\n " + ], + [ + "a ", + "& b) + (" + ], + [ + ") external ", + "onlyOwner {\\n " + ], + [ + "that ", + "can " + ], + [ + "air", + " " + ], + [ + "The ", + "new " + ], + [ + ";\\n\\n ", + "/**\\n * @notice " + ], + [ + "only ", + "way to " + ], + [ + "Buy", + "Back" + ], + [ + "ERC721A", + ", " + ], + [ + ");\\r\\n", + "\\r\\n " + ], + [ + "ren", + "ce " + ], + [ + "get ", + "them" + ], + [ + "signature ", + "parameters, " + ], + [ + "NOT", + "_" + ], + [ + "ERC20 ", + "allowance " + ], + [ + "When ", + "the " + ], + [ + "Rem", + "ote" + ], + [ + ") internal {\\n ", + "uint256 " + ], + [ + ", which ", + "can be used to " + ], + [ + "instead", + " of the " + ], + [ + "send ", + "a transaction" + ], + [ + "curr", + "Slot" + ], + [ + "OL", + "D" + ], + [ + "and the ", + "only way to " + ], + [ + "Pri", + "or" + ], + [ + "13", + "8" + ], + [ + "0x7", + "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" + ], + [ + "ownership.", + "burned" + ], + [ + "clusi", + "ve" + ], + [ + "token/ERC721/extensions/", + "IERC721Enumerable" + ], + [ + "'s\\n * ", + "purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had" + ], + [ + "call to non-contract\\\");\\n\\n ", + "// solhint-disable-next-line avoid-low-level-call" + ], + [ + "92", + "F" + ], + [ + "s\\n ", + "(bool success, bytes memory returndata) = target" + ], + [ + "_d", + "ollar" + ], + [ + "manual", + "Burn" + ], + [ + "18 ", + "decimal " + ], + [ + "Remain", + "ing" + ], + [ + ";\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-", + "tokenURI}.\\n */\\n function " + ], + [ + "ds-", + "test" + ], + [ + "swit", + "ch " + ], + [ + "alp", + "ha" + ], + [ + ";\\n }\\n if (", + "t & 0x" + ], + [ + "tosh", + "is" + ], + [ + " in min", + "d " + ], + [ + "ecrecover ", + "takes the " + ], + [ + "directly or ", + "indirectly" + ], + [ + "Adds the ", + "{permit} method" + ], + [ + " {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account", + " to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount" + ], + [ + "admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change ", + "a role's admin, use {" + ], + [ + "Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function", + "'s\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had" + ], + [ + ";\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function ", + "symbol() public view virtual override returns (string memory) {\\n return _symbol" + ], + [ + "-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name", + ";\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol" + ], + [ + "signature parameters, ", + "and the only way to " + ], + [ + ", which can be used to ", + "change " + ], + [ + "call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-call", + "s\\n (bool success, bytes memory returndata) = target" + ], + [ + "Adds the {permit} method", + ", which can be used to change " + ], + [ + "signature parameters, and the only way to ", + "get them" + ], + [ + "\"", + "/" + ], + [ + "9", + "e" + ], + [ + "F", + "LOW" + ], + [ + "_", + "s" + ], + [ + ", ", + "from, " + ], + [ + ");", + "\\r\\n event " + ], + [ + "ing ", + "into " + ], + [ + "im", + "ag" + ], + [ + "el", + "imin" + ], + [ + " = ", + "_ownership" + ], + [ + "es ", + "to " + ], + [ + "s:", + "\\n *\\n * " + ], + [ + "value ", + "for the " + ], + [ + "the zero address", + "\\\");\\r\\n\\r\\n " + ], + [ + "the", + "\\r\\n * " + ], + [ + "Mint", + "Per" + ], + [ + ").", + "min " + ], + [ + ",\\n uint256 ", + "amount" + ], + [ + "Allowanc", + "e " + ], + [ + "updat", + "es are " + ], + [ + "(_", + "IMPLEMENTATION_SLOT" + ], + [ + "sell", + "OperationsFee" + ], + [ + ".\\n * ", + "@return " + ], + [ + " == ", + "owner" + ], + [ + ") {\\n ", + "return " + ], + [ + "_burn", + "(account, amount" + ], + [ + "Ro", + "ot " + ], + [ + "er is not ", + "guarante" + ], + [ + "approval", + "s to be " + ], + [ + "Slot", + "(bytes32 slot) internal pure returns (" + ], + [ + " > 0", + ") {\\n // " + ], + [ + "tokenId ", + "The " + ], + [ + "Length", + " = " + ], + [ + "initial", + "Balance" + ], + [ + "`from` to `to", + "`.\\n *\\n * This internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n */\\n function _transfer" + ], + [ + "Fun", + "ds" + ], + [ + "access/", + "IAccessControl" + ], + [ + "== 0", + ") " + ], + [ + "slot ", + "of " + ], + [ + "UN", + "D" + ], + [ + "78", + " " + ], + [ + "keccak256(", + "\\n " + ], + [ + "ord", + "er is not guarante" + ], + [ + ", as ", + "defined " + ], + [ + "sal", + "es " + ], + [ + "Mem", + "ory" + ], + [ + ". Th", + "ese " + ], + [ + ".\\n * ", + "@param " + ], + [ + "IERC", + "777" + ], + [ + "hel", + "per " + ], + [ + "Extension", + " of " + ], + [ + "execut", + "e" + ], + [ + "-26", + "12" + ], + [ + "override(", + "ERC165, IERC165" + ], + [ + "still ", + "allows " + ], + [ + "][operator", + "] = approved;\\n emit ApprovalForAll" + ], + [ + "];\\n }\\n\\n /**\\n * @dev See {IERC721-", + "transferFrom}.\\n */\\n function " + ], + [ + "reveal", + "ed" + ], + [ + ") external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from ", + "`sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom" + ], + [ + "_transfer(from, to, tokenId", + ");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function " + ], + [ + "redis", + "FeeOnBuy" + ], + [ + "made ", + "via " + ], + [ + ") {\\n ", + "// " + ], + [ + "simp", + "ly " + ], + [ + "ed as ", + "updates are " + ], + [ + ", \\\"!", + "auth" + ], + [ + "charact", + "er " + ], + [ + "filtered operator", + "s and " + ], + [ + "branc", + "h" + ], + [ + ".\\n * Note that ", + "order is not guarante" + ], + [ + "address or ", + "its subscription" + ], + [ + "D5", + "76" + ], + [ + "made", + ".\\n */\\n function " + ], + [ + ";\\n\\n/**\\n * @dev Interface ", + "of " + ], + [ + "Registe", + "red" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}", + "(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall" + ], + [ + "percentFor", + "LPBurn" + ], + [ + "recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function ", + "transfer(address recipient, uint256 amount" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function ", + "_transfer" + ], + [ + "Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] ", + "Non-Fungible Token Standard, includ" + ], + [ + "-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol", + ";\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function " + ], + [ + "approvals to be ", + "made via " + ], + [ + "ed as updates are ", + "made.\\n */\\n function " + ], + [ + ".\\n * Note that order is not guarante", + "ed as updates are made.\\n */\\n function " + ], + [ + " ", + "p0) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(bytes" + ], + [ + "\"", + "F" + ], + [ + "$", + "/" + ], + [ + "F", + "E_" + ], + [ + "R", + "ig" + ], + [ + "[", + "sender" + ], + [ + "]", + ";\\n\\n // " + ], + [ + "m", + "et" + ], + [ + "v", + "s\\n " + ], + [ + "y", + ",\\n uint256 denominator" + ], + [ + "~", + "~" + ], + [ + "int", + " " + ], + [ + "return", + "Data" + ], + [ + "the ", + "sum of all " + ], + [ + "all", + "y" + ], + [ + "ex", + "clude" + ], + [ + "as", + "\\n * " + ], + [ + "ing ", + "of the " + ], + [ + "im", + "d" + ], + [ + "Id", + "s" + ], + [ + "account", + "Hash" + ], + [ + "Tr", + "ans" + ], + [ + "sh", + "ort " + ], + [ + "In", + "st" + ], + [ + "index", + " for the " + ], + [ + ";\\n ", + "address " + ], + [ + ";\\n ", + "}\\n }\\n\\n " + ], + [ + ";\\n ", + "for (uint256 i = 0; i < " + ], + [ + "only", + "Minter" + ], + [ + ";\\n\\n ", + "/// @dev " + ], + [ + "swap", + "Router" + ], + [ + "will ", + "fail" + ], + [ + "ra", + "re" + ], + [ + "Role", + "Data" + ], + [ + "(_", + "packedOwnershipOf(tokenId" + ], + [ + "Tax", + "Fee" + ], + [ + "string memory", + ") {\\r\\n return " + ], + [ + "RO", + "M" + ], + [ + ", and ", + "thus " + ], + [ + "Con", + "vex" + ], + [ + "ref", + "lection" + ], + [ + ";\\n }\\n\\n ", + "/**\\n * " + ], + [ + "At", + "(address registrant" + ], + [ + "sum", + "m" + ], + [ + "reward", + "Token" + ], + [ + "SA", + "FE_" + ], + [ + "paused", + ".\\n */\\n modifier " + ], + [ + "addition", + " overflow" + ], + [ + "\\\");\\n return ", + "c" + ], + [ + ")\\n ", + ")\\n " + ], + [ + ";\\r\\n ", + " " + ], + [ + "Rewards", + "Fee" + ], + [ + "(address(0), to, ", + "tokenId);\\n\\n " + ], + [ + "checkpoint", + "s[" + ], + [ + "Cur", + "ve " + ], + [ + "F5", + "D576" + ], + [ + "aun", + "ch" + ], + [ + "Snapshot", + "Id" + ], + [ + "IL", + "L" + ], + [ + "proxy", + "." + ], + [ + "mean", + "ing " + ], + [ + "FE", + "92F" + ], + [ + "Stak", + "ed" + ], + [ + "1)", + "`." + ], + [ + ",\\n bytes32 r,\\n bytes32 ", + "vs\\n " + ], + [ + "ceil", + "Div" + ], + [ + "r := ", + "mload(add(signature, 0x20" + ], + [ + "1B", + "20" + ], + [ + "pause(", + ") internal virtual " + ], + [ + "(\\n bytes32 hash", + ",\\n bytes32 r,\\n bytes32 vs\\n " + ], + [ + "DD", + "FE92F" + ], + [ + "acces", + "s to " + ], + [ + "\\n ) external payable", + ";\\n\\n /**\\n * @dev " + ], + [ + "Fir", + "st" + ], + [ + "Purch", + "ase" + ], + [ + "A4", + "501" + ], + [ + "hasRole(role, account)) {\\n ", + "_roles[role].members[account" + ], + [ + "E7", + "357" + ], + [ + "on\\r\\n * ", + "overflow" + ], + [ + "Wrappers over Solidity's ", + "arithmetic operation" + ], + [ + "solhint-disable-next-line max-line-length", + "\\n require(" + ], + [ + "Erc", + "20" + ], + [ + "ali", + "as" + ], + [ + "4668", + "1B20" + ], + [ + "(\\n uint256 x,\\n uint256 ", + "y,\\n uint256 denominator" + ], + [ + "0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", + "F5D576" + ], + [ + "At(address registrant", + ", uint256 index" + ], + [ + "DDFE92F", + "46681B20" + ], + [ + "A4501", + "DDFE92F46681B20" + ], + [ + "E7357", + "A4501DDFE92F46681B20" + ], + [ + "0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576", + "E7357A4501DDFE92F46681B20" + ], + [ + "\"", + "\\x19" + ], + [ + "%", + "@" + ], + [ + "(", + ") internal view virtual override returns (" + ], + [ + "*", + " _" + ], + [ + "9", + "d" + ], + [ + "I", + "WETH" + ], + [ + "S", + "ent" + ], + [ + "T", + "Y" + ], + [ + "_", + "addedValue" + ], + [ + "c", + "ed" + ], + [ + "g", + "rowth" + ], + [ + "s", + "\\n // " + ], + [ + "v", + "ested" + ], + [ + "w", + "ill" + ], + [ + "en", + "ough" + ], + [ + "on", + "Swap" + ], + [ + "\\n ", + ");\\n\\n " + ], + [ + "un", + "n" + ], + [ + "ac", + "58" + ], + [ + "is ", + "to use " + ], + [ + "to ", + "mint" + ], + [ + "from", + "] " + ], + [ + "acc", + "ord" + ], + [ + "ul", + "ar" + ], + [ + "in ", + "this " + ], + [ + "at ", + "`index" + ], + [ + "ke", + "y " + ], + [ + "swap", + "FeePercentage" + ], + [ + " ", + " " + ], + [ + "@@@@", + "@" + ], + [ + "(_", + "projectId" + ], + [ + "s, ", + "and " + ], + [ + "Min", + "im" + ], + [ + "`tokenId` ", + "will be " + ], + [ + ")\\n ", + "private" + ], + [ + "24", + "8" + ], + [ + "AR", + "Y" + ], + [ + ";\\n }\\n\\n function ", + "get" + ], + [ + "version", + " of the " + ], + [ + "s = ", + "new uint256" + ], + [ + "_buy", + "LiquidityFee" + ], + [ + "instead", + " of " + ], + [ + "ATION", + "_TYPEHASH" + ], + [ + "solhint-", + "disable " + ], + [ + "gi", + "ve " + ], + [ + "Bytes32", + "Set storage set" + ], + [ + "kee", + "per" + ], + [ + "Govern", + "ance " + ], + [ + "\\n override", + "\\n " + ], + [ + "80", + "ac58" + ], + [ + " = 1", + " << " + ], + [ + "batch", + "Size" + ], + [ + "except ", + "the " + ], + [ + "safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ", + ") public virtual override {\\n " + ], + [ + ".\\r\\n ", + " */\\r\\n function " + ], + [ + "when dividing by ", + "zero.\\n *\\n * Counterpart to Solidity's `" + ], + [ + "_removeTokenFrom", + "AllTokensEnumeration" + ], + [ + "currently ", + "is to use " + ], + [ + "E_P", + "ERCENT" + ], + [ + "_addTokenTo", + "AllTokensEnumeration" + ], + [ + "EnumerableSet.", + "AddressSet" + ], + [ + "(\\n bytes32 hash", + ",\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n " + ], + [ + "\\\"],\\n [", + "\\\"H" + ], + [ + "allowing ", + "approvals to be made via " + ], + [ + "StorageSlot.get", + "AddressSlot" + ], + [ + "}.\\n */\\n ", + "// solhint-disable-next-line func-name-mixedcase\\n function " + ], + [ + "``sender", + "``'s " + ], + [ + "ecrecover takes the ", + "signature parameters, and the only way to get them" + ], + [ + ", as defined ", + "in\\n * " + ], + [ + "currently is to use ", + "assembly" + ], + [ + "allowing approvals to be made via ", + "signatures" + ], + [ + " ", + "ether" + ], + [ + "\"", + "S" + ], + [ + "\"", + "SafeERC20: " + ], + [ + "(", + "c" + ], + [ + "(", + "see" + ], + [ + "+", + "= _" + ], + [ + "q", + "ty" + ], + [ + "v", + "Share" + ], + [ + "\\n", + "/// @notice " + ], + [ + "\\n", + "\\n uint256 " + ], + [ + "\\n ", + "struct " + ], + [ + "un", + "necessary" + ], + [ + "is", + ", " + ], + [ + "ic", + "ate" + ], + [ + "us", + "age " + ], + [ + "20", + " bytes " + ], + [ + ".\\n *\\n * ", + "WARNING: " + ], + [ + "pri", + "mary " + ], + [ + "value ", + "(" + ], + [ + "its ", + "L" + ], + [ + ").", + "sub(" + ], + [ + "old", + "Weight" + ], + [ + " b", + "atch " + ], + [ + "start", + "ed" + ], + [ + "cent", + "er" + ], + [ + "IERC20-", + "allowance" + ], + [ + "pres", + "er" + ], + [ + "app", + "end" + ], + [ + "Po", + "inter" + ], + [ + " ", + "`" + ], + [ + "gas ", + "to " + ], + [ + ") {\\n require(", + "value >= " + ], + [ + "&& ", + "value <= type(" + ], + [ + ")\\n ", + "external" + ], + [ + "ing a ", + "message " + ], + [ + ", the ", + "swap " + ], + [ + "\\n * @", + "title" + ], + [ + ")\\n external", + "\\n view" + ], + [ + "[EIP", + "-2612" + ], + [ + "fund", + "s" + ], + [ + "ates ", + "an " + ], + [ + "mapping ", + "(address =\\u003e " + ], + [ + "state", + ".\\n *\\n * Requirements:\\n *\\n * - The contract " + ], + [ + "aux", + "ili" + ], + [ + "(uint256 value) internal pure returns (", + "uint" + ], + [ + "arith", + "m" + ], + [ + "Signed", + "MintValidation" + ], + [ + "decrement", + " the " + ], + [ + ":\\n *", + "\\n * - `" + ], + [ + "starting ", + "token ID" + ], + [ + "free", + "Memory" + ], + [ + "timelock", + "List" + ], + [ + "following ", + "is " + ], + [ + "ed\\n * ", + "to " + ], + [ + "ing\\n * ", + "the " + ], + [ + "reser", + "ve " + ], + [ + "];\\n\\n ", + "if (" + ], + [ + "Permit ", + "extension " + ], + [ + "mark", + "ed " + ], + [ + "ins", + "ert" + ], + [ + "token/ERC721/IERC721Receiver", + ".sol\"" + ], + [ + "Upgrad", + "ed" + ], + [ + "hashTypedDataV4", + "(" + ], + [ + "https://eips.ethereum.org/EIPS/eip-712", + "#" + ], + [ + "https://eips.ethereum.org/EIPS/eip-2612", + "[EIP-2612" + ], + [ + "`account`", + ".\\n */\\n event " + ], + [ + "4.0", + " (" + ], + [ + "receive() external payable ", + "{" + ], + [ + "RARE", + "LOOKS" + ], + [ + "Hook that is called before any token transfer. This includes ", + "minting\\n * " + ], + [ + "/* ========", + "== " + ], + [ + " {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount", + ") external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom" + ], + [ + ").min ", + "&& value <= type(" + ], + [ + ") {\\n require(value >= ", + "type(" + ], + [ + "Permit extension ", + "allowing approvals to be made via signatures" + ], + [ + " ", + "D" + ], + [ + "(", + "address, " + ], + [ + "0", + ")\\n " + ], + [ + "A", + "nti" + ], + [ + "B", + "its L" + ], + [ + "H", + "I" + ], + [ + "T", + "O" + ], + [ + "_", + "g" + ], + [ + "_", + "sellLiquidityFee" + ], + [ + "d", + "ue" + ], + [ + "k", + "ind" + ], + [ + "r", + "f" + ], + [ + "s", + "ch" + ], + [ + "re", + "pe" + ], + [ + "s ", + "save " + ], + [ + "in", + "ner" + ], + [ + "un", + "it " + ], + [ + "uint256", + ")\"" + ], + [ + "am", + "ond" + ], + [ + "is ", + "within bound" + ], + [ + "account", + " is " + ], + [ + "account", + ". By " + ], + [ + "not ", + "relying on " + ], + [ + ";\\n\\n ", + "address public " + ], + [ + "eth", + "ier" + ], + [ + "mapping", + "(address =\\u003e " + ], + [ + "Bu", + "ffer" + ], + [ + "cannot be ", + "removed from " + ], + [ + "have ", + "a " + ], + [ + ";\\n ", + "// " + ], + [ + "is not ", + "required to " + ], + [ + ".sol\\\";\\nimport \\\"", + "@balancer-labs/v2-" + ], + [ + "Metadata", + "Uri" + ], + [ + "account ", + "doesn't" + ], + [ + "present", + "ing a message " + ], + [ + "fees", + ". " + ], + [ + "not", + "e that " + ], + [ + "gener", + "ating " + ], + [ + "Allow", + "list" + ], + [ + "();\\n ", + "uint256 " + ], + [ + "();\\n ", + "}\\n " + ], + [ + "which", + " to " + ], + [ + ") internal virtual {\\n require(", + "sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: " + ], + [ + "renounce", + "Role" + ], + [ + "_currentIndex", + " " + ], + [ + "[0", + ".." + ], + [ + "Can ", + "be " + ], + [ + "s with ", + "added " + ], + [ + "subtraction", + " overflow" + ], + [ + "Is", + "su" + ], + [ + "implementation ", + "for " + ], + [ + "need to ", + "send a transaction" + ], + [ + ").\\n *\\n * Counterpart to Solidity's `", + "-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub" + ], + [ + ");\\n }\\n\\n /**\\n * @dev See {IERC721-", + "balanceOf}.\\n */\\n function balanceOf(address owner" + ], + [ + "Ether ", + "at all" + ], + [ + ".\\n *\\n * Emits a {Transfer} event.\\n */\\n function _", + "mint" + ], + [ + ".\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue", + "(address target, bytes memory data, uint256 value" + ], + [ + "uniswap", + " " + ], + [ + "Array", + "(" + ], + [ + "type ", + "`" + ], + [ + "Delet", + "e the " + ], + [ + "don't ", + "need to " + ], + [ + "JoinExit", + "Invariant" + ], + [ + "(address registrant, address ", + "registrant" + ], + [ + "(\\n ", + "address " + ], + [ + "hold ", + "Ether at all" + ], + [ + "pair ", + "cannot be removed from " + ], + [ + "revoked ", + "`role" + ], + [ + "_take", + "Team" + ], + [ + "Cr", + "v" + ], + [ + "signed by the ", + "account. By " + ], + [ + "(see {", + "IERC20-allowance" + ], + [ + "< b", + " ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of " + ], + [ + "\\n *\\n * Emits ", + "a {" + ], + [ + "Ap", + "ach" + ], + [ + "Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := ", + "slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `" + ], + [ + ";\\npragma ", + "experimental ABIEncoderV2" + ], + [ + "token holder ", + "account doesn't" + ], + [ + "an account's ", + "ERC20 allowance " + ], + [ + ".onERC721Received.selector`.\\n */\\n function ", + "onERC721Received(\\n address operator,\\n address from,\\n uint256 tokenId,\\n bytes calldata data\\n ) external returns (bytes4" + ], + [ + "(_msgSender(), operator, approved", + ");\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll" + ], + [ + "Initialize the ", + "next " + ], + [ + "common/", + "ERC2981" + ], + [ + "Adds the {permit} method, which can be used to change ", + "an account's ERC20 allowance " + ], + [ + ", and thus ", + "is not required to " + ], + [ + "Bits L", + "ayout:" + ], + [ + "presenting a message ", + "signed by the account. By " + ], + [ + "need to send a transaction", + ", and thus is not required to " + ], + [ + "(see {IERC20-allowance", + "}) " + ], + [ + "Adds the {permit} method, which can be used to change an account's ERC20 allowance ", + "(see {IERC20-allowance}) " + ], + [ + "presenting a message signed by the account. By ", + "not relying on " + ], + [ + "need to send a transaction, and thus is not required to ", + "hold Ether at all" + ], + [ + "(", + "gas" + ], + [ + "A", + "MM" + ], + [ + "F", + "A" + ], + [ + "]", + " `" + ], + [ + "`", + "balance " + ], + [ + "f", + "raction" + ], + [ + "s", + "afely " + ], + [ + "}", + "\\n\\n " + ], + [ + "\\n", + "pragma solidity ^0.8.0" + ], + [ + "un", + "packed " + ], + [ + "or", + "k" + ], + [ + "// ", + "ERC165 interface ID for " + ], + [ + "\\n *", + " " + ], + [ + "ve", + "/" + ], + [ + "be ", + "used by " + ], + [ + " = ", + "address(uint160(" + ], + [ + "appro", + "x" + ], + [ + "32", + "-byte " + ], + [ + "} ", + "for " + ], + [ + "zero ", + "and not " + ], + [ + "For", + "Penalty" + ], + [ + "\\r\\n ", + ") external returns (" + ], + [ + "swap", + "Request" + ], + [ + "zero", + ")." + ], + [ + "block", + "ing" + ], + [ + "] = ", + "prevOwnershipPacked" + ], + [ + "false", + ";\\n }\\n }\\n\\n /**\\n * @dev " + ], + [ + "overflow", + " because the " + ], + [ + "= _", + "packedOwnershipOf(tokenId" + ], + [ + "En", + "sure the " + ], + [ + "_mint", + "(" + ], + [ + "Updat", + "es: " + ], + [ + "next", + "Initializ" + ], + [ + "exp", + "ired" + ], + [ + "block.timestamp", + " >= " + ], + [ + "; // ", + "Updates: " + ], + [ + "given ", + "by the " + ], + [ + ") / ", + "100" + ], + [ + "packed ", + "value is " + ], + [ + "Slot", + "` with member `value` located at `slot`.\\n */\\n function get" + ], + [ + " bits", + "\\n *\\n * " + ], + [ + "delet", + "e is the " + ], + [ + "` operator", + ".\\r\\n *\\r\\n * Requirements:\\r\\n *\\r\\n * - " + ], + [ + "renoun", + "ce " + ], + [ + "_balances[account", + "] += amount;\\n " + ], + [ + "lp", + "token" + ], + [ + "have been ", + "initializ" + ], + [ + "Stor", + "age " + ], + [ + "ates ", + "a " + ], + [ + "reentr", + "ant" + ], + [ + "i.", + "function" + ], + [ + ".selector", + " ^ " + ], + [ + "();\\n\\n ", + "if (" + ], + [ + "TRA", + "NSFER_" + ], + [ + "aux", + "Casted " + ], + [ + "approve}", + ".\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount" + ], + [ + "increment", + "ing" + ], + [ + "\\t\\t", + "// " + ], + [ + "uint24", + "(" + ], + [ + "i.e. ", + "packed value is " + ], + [ + ": invalid ", + "signature" + ], + [ + "\\\");\\n _", + ";\\n }\\n\\n " + ], + [ + "snapshot", + "Id" + ], + [ + "callOptionalReturn", + "(token, abi.encodeWithSelector(token.approve.selector, " + ], + [ + "ed (", + "i.e. `" + ], + [ + "abs", + "Tick" + ], + [ + ";\\n }\\n\\n /**\\n * @dev See {IERC721-", + "approve}.\\n */\\n function approve(address to, uint256 tokenId" + ], + [ + "trig", + "g" + ], + [ + "vali", + "date" + ], + [ + "for `owner", + "Of(" + ], + [ + "ownership.addr", + " != address(0)" + ], + [ + "If the next ", + "slot's " + ], + [ + "address is ", + "zero and not " + ], + [ + ".\\r\\n ", + " *\\r\\n * " + ], + [ + "tokenId + ", + "1)`." + ], + [ + "prevOwnershipPacked ", + "= _packedOwnershipOf(tokenId" + ], + [ + "token/ERC721/extensions/IERC721Metadata", + ".sol\"" + ], + [ + ").interfaceId ||\\n ", + "super.supportsInterface(interfaceId" + ], + [ + "may not ", + "have been initializ" + ], + [ + "(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes", + "-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.delegatecall" + ], + [ + "decimals = ", + "18" + ], + [ + "getRoleMember", + "Count" + ], + [ + "_packedOwnerships[nextTokenId", + "] = prevOwnershipPacked" + ], + [ + "If the next slot ", + "is within bound" + ], + [ + "If the next slot ", + "may not have been initializ" + ], + [ + "withdrawable", + "Dividend" + ], + [ + "'s", + "' value" + ], + [ + "_status = _", + "NOT_ENTERED" + ], + [ + "maintain correctness ", + "for `ownerOf(" + ], + [ + "utch", + "Auction" + ], + [ + "burned (", + "i.e. packed value is " + ], + [ + "slot to ", + "maintain correctness for `ownerOf(" + ], + [ + "iph", + "ery" + ], + [ + "ed == false", + "`) " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Convert", + "s an " + ], + [ + "operation is ", + "unnecessary" + ], + [ + ") public virtual override returns (bool) {\\n address spender = _msgSender();\\n _spendAllowance(from, spender, amount);\\n _transfer(from, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, allowance(owner, spender) + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n uint256 currentAllowance = allowance(owner, spender);\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - subtractedValue);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves `amount` of tokens from ", + "`from` to `to`.\\n *\\n * This internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n */\\n function _transfer" + ], + [ + "slot of ", + "tokenId" + ], + [ + "recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount", + ") public virtual override returns (bool) {\\n _transfer" + ], + [ + "-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function ", + "tokenURI(uint256 tokenId) public view virtual override returns (" + ], + [ + ", the swap ", + "operation is unnecessary" + ], + [ + "Hook that is called before any token transfer. This includes minting\\n * ", + "and burning.\\n *\\n * Calling conditions:\\n *\\n * - " + ], + [ + "Initialize the next ", + "slot to maintain correctness for `ownerOf(" + ], + [ + "unpacked ", + "`TokenOwnership` struct " + ], + [ + "nextInitializ", + "ed == false`) " + ], + [ + "; // Updates: ", + "`balance " + ], + [ + "ed (i.e. `", + "nextInitialized == false`) " + ], + [ + "If the next slot's ", + "address is zero and not " + ], + [ + "If the next slot is within bound", + "s." + ], + [ + "If the next slot may not have been initializ", + "ed (i.e. `nextInitialized == false`) " + ], + [ + "burned (i.e. packed value is ", + "zero)." + ], + [ + "Initialize the next slot to maintain correctness for `ownerOf(", + "tokenId + 1)`." + ], + [ + "If the next slot's address is zero and not ", + "burned (i.e. packed value is zero)." + ], + [ + "\"", + "Buy " + ], + [ + "&", + " (" + ], + [ + "'", + ")) == " + ], + [ + "P", + "aid" + ], + [ + "W", + "ad" + ], + [ + "[", + "_tokenId" + ], + [ + "`", + "_to" + ], + [ + "e", + "0" + ], + [ + "f", + "requency" + ], + [ + "h", + "ard" + ], + [ + "i", + "eld " + ], + [ + "s ", + "or " + ], + [ + "s ", + "all " + ], + [ + ", ", + "uint64 " + ], + [ + "ed", + "\\n // " + ], + [ + "at", + "ely " + ], + [ + "pp", + "ed " + ], + [ + "a ", + "block" + ], + [ + "cont", + "roller" + ], + [ + "et", + "y " + ], + [ + "ec", + "t to " + ], + [ + "el", + "aps" + ], + [ + "\\n * ", + "need to send a transaction, and thus is not required to hold Ether at all" + ], + [ + "af", + "fi" + ], + [ + "mo", + "st" + ], + [ + "****", + "***" + ], + [ + "max", + "Per" + ], + [ + "check", + "s." + ], + [ + "can ", + "overflow" + ], + [ + "id", + "th" + ], + [ + "See {", + "IERC721-" + ], + [ + "` to ", + "the owner" + ], + [ + "_S", + "WAP" + ], + [ + "of `", + "tokenId" + ], + [ + "tokensFor", + "Liquidity " + ], + [ + "\\r\\n ", + " *\\r\\n * " + ], + [ + "dig", + "italMedia" + ], + [ + "_r", + "ate" + ], + [ + "$$", + " " + ], + [ + "CON", + "STRUCT" + ], + [ + "Config", + "." + ], + [ + "VER", + "FLOW" + ], + [ + "].\\n *\\n * ", + "Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) " + ], + [ + "sent", + " in " + ], + [ + "expensi", + "ve" + ], + [ + "isExcludedFrom", + "Fee" + ], + [ + "bit", + "map" + ], + [ + "_approve(_msgSender(), ", + "spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20" + ], + [ + "int24", + " " + ], + [ + "onlyRole(", + "getRoleAdmin(role" + ], + [ + "BITPOS_NUMBER_MINTED", + ") | " + ], + [ + "by\\n * ", + "presenting a message signed by the account. By not relying on " + ], + [ + "totalSupply()", + " * " + ], + [ + "string memory name", + ", string memory " + ], + [ + "_INTER", + "FACE_ID_" + ], + [ + "numberMinted ", + "+= quantity" + ], + [ + "} to enumerate ", + "all " + ], + [ + "paused(), \\\"", + "Pausable: " + ], + [ + "` is zero, ``from``'s ", + "`tokenId` will be " + ], + [ + "_dollar", + "_value" + ], + [ + ", as defined in\\n * ", + "https://eips.ethereum.org/EIPS/eip-2612[EIP-2612" + ], + [ + "Permit extension allowing approvals to be made via signatures", + ", as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612" + ], + [ + ") internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: ", + "transfer to the zero address\\\");\\n\\n _beforeTokenTransfer" + ], + [ + "token holder account doesn't", + "\\n * need to send a transaction, and thus is not required to hold Ether at all" + ], + [ + ".onERC721Received.selector`.\\n */\\n function onERC721Received(\\n address operator,\\n address from,\\n uint256 tokenId,\\n bytes calldata data\\n ) external returns (bytes4", + ");\\n}\\n\"" + ], + [ + "affi", + "li" + ], + [ + "].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) ", + "by\\n * presenting a message signed by the account. By not relying on " + ], + [ + "BITPOS_NUMBER_MINTED) | ", + "1" + ], + [ + "Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612", + "].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on " + ], + [ + "\"", + "Sell " + ], + [ + "(", + "_msgSenderERC721A" + ], + [ + "(", + "operator, " + ], + [ + "/", + "^" + ], + [ + "3", + ", " + ], + [ + "P", + "latform" + ], + [ + "_", + "swapEnabled" + ], + [ + "_", + "time" + ], + [ + "_", + "dexRouter" + ], + [ + "_", + "contains" + ], + [ + "_", + "srcAddress" + ], + [ + "`", + "proof" + ], + [ + "l", + "ector" + ], + [ + "m", + "arket " + ], + [ + "t", + "." + ], + [ + ") ", + "are " + ], + [ + "the ", + "transaction " + ], + [ + "is ", + "missing role " + ], + [ + "// ", + "If the next slot is within bounds." + ], + [ + "cont", + "ain " + ], + [ + "dev", + "FeeReceiver" + ], + [ + "Token", + "\"" + ], + [ + ",\\n ", + "bool" + ], + [ + "pro", + "v" + ], + [ + " of ", + "the\\n // " + ], + [ + ") external ", + "payable" + ], + [ + "Call", + "back" + ], + [ + "up", + " the " + ], + [ + "its ", + "own " + ], + [ + "Op", + "tim" + ], + [ + "0x", + "[0-9a-f]{" + ], + [ + "Requirements:", + "\\n * - " + ], + [ + "mod", + "(" + ], + [ + "of the ", + "revert reason is " + ], + [ + "Liquidity", + "With" + ], + [ + "remo", + "ve the " + ], + [ + "ate ", + "a " + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `", + "index` must be strictly less than {length" + ], + [ + "in the ", + "set. O(1).\\n *\\n * " + ], + [ + "token/", + "common/ERC2981" + ], + [ + "\"@openzeppelin/contracts/", + "token/ERC721/IERC721Receiver.sol\"" + ], + [ + "exp", + "on" + ], + [ + "assembly ", + "to avoid " + ], + [ + "IM", + "AL" + ], + [ + "the\\n * ", + "array, and it may change when more values are added or removed" + ], + [ + ") public virtual override ", + "onlyRole(getRoleAdmin(role" + ], + [ + "_set", + "Owner(" + ], + [ + "put ", + "in " + ], + [ + "account (", + "0x[0-9a-f]{" + ], + [ + "\\n ) external ", + "payable " + ], + [ + "key", + "s" + ], + [ + "(0x", + "[0-9a-f]{" + ], + [ + "next ", + "token ID" + ], + [ + "origin", + "al" + ], + [ + "Pric", + "e = " + ], + [ + ":\\n *", + "\\n * " + ], + [ + "mask", + "ing" + ], + [ + ", \\\"SafeMath: ", + "division by zero" + ], + [ + "regular ", + "expres" + ], + [ + "approveMax", + ", uint8 v, bytes32 r, bytes32 s" + ], + [ + "following ", + "regular expres" + ], + [ + "upgrad", + "es " + ], + [ + "(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n ", + "unchecked {\\n " + ], + [ + "AccessControl: ", + "account (0x[0-9a-f]{" + ], + [ + "uint256) private ", + "_balances" + ], + [ + "}) ", + "is missing role " + ], + [ + "utils/cryptography/", + "ECDSA" + ], + [ + "propor", + "tional" + ], + [ + "format ", + "of the revert reason is " + ], + [ + "Note that there are no guarantees on the ordering of values inside ", + "the\\n * array, and it may change when more values are added or removed" + ], + [ + "signator", + "y" + ], + [ + "value stored at position `index` ", + "in the set. O(1).\\n *\\n * " + ], + [ + "becom", + "es " + ], + [ + "blockNum", + "ber " + ], + [ + "wri", + "ting " + ], + [ + ".\\n */\\n function mulDiv", + "(\\n uint256 x,\\n uint256 y,\\n uint256 denominator" + ], + [ + "})", + "$/" + ], + [ + "sqrtPrice", + "X96" + ], + [ + "Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, includ", + "ing\\n * the " + ], + [ + "\\\"],\\n [\\\"H", + "air " + ], + [ + "given by the ", + "following regular expres" + ], + [ + "(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.delegatecall", + "(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {" + ], + [ + "_packedOwnerships[nextTokenId] = prevOwnershipPacked", + ";" + ], + [ + "frequency", + "In" + ], + [ + "(_msgSenderERC721A", + "(), " + ], + [ + "/^", + "AccessControl: account (0x[0-9a-f]{" + ], + [ + ") public virtual override onlyRole(getRoleAdmin(role", + ")" + ], + [ + "}) is missing role ", + "(0x[0-9a-f]{" + ], + [ + "format of the revert reason is ", + "given by the following regular expres" + ], + [ + "Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed", + ".\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length" + ], + [ + "value stored at position `index` in the set. O(1).\\n *\\n * ", + "Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length" + ], + [ + "format of the revert reason is given by the following regular expres", + "sion" + ], + [ + "(", + ");\\n }\\n\\n " + ], + [ + "1", + "%" + ], + [ + "A", + "s " + ], + [ + "B", + "ound" + ], + [ + "C", + "L" + ], + [ + "D", + "at" + ], + [ + "G", + "old" + ], + [ + "S", + "qu" + ], + [ + "_", + "type" + ], + [ + "_", + "create" + ], + [ + "_", + "tradingOpen" + ], + [ + "b", + "est " + ], + [ + "i", + "re" + ], + [ + "j", + "ob" + ], + [ + "s", + "can" + ], + [ + "x", + "112" + ], + [ + "{", + "Transfer} event" + ], + [ + "\\n ", + "@notice " + ], + [ + "s ", + "must be " + ], + [ + "s ", + "if the " + ], + [ + "in", + "vocation" + ], + [ + ") ", + "// " + ], + [ + "the ", + "return " + ], + [ + ");", + "\\r\\n " + ], + [ + "\\\"", + ");\\n\\n " + ], + [ + "is ", + "capp" + ], + [ + "ing ", + "then " + ], + [ + "call", + "back" + ], + [ + "return ", + "result" + ], + [ + " = ", + "((" + ], + [ + "wh", + "om" + ], + [ + "wh", + "ose " + ], + [ + ") public ", + "only" + ], + [ + "ff", + "f" + ], + [ + "a s", + "torage " + ], + [ + "(uint256 ", + "id" + ], + [ + "up", + "scal" + ], + [ + "current", + "Day" + ], + [ + " is ", + "preser" + ], + [ + "totalSupply", + ", and the " + ], + [ + "log", + "arithm" + ], + [ + "mod", + "ule" + ], + [ + "ed by ", + "totalSupply, and the " + ], + [ + "Math", + "._" + ], + [ + "/\\n ", + "/// " + ], + [ + " for ", + "contracts " + ], + [ + "base", + "Token" + ], + [ + "ved ", + "by" + ], + [ + "sum", + " is preser" + ], + [ + "address,", + "uint256," + ], + [ + "es[", + "msg.sender" + ], + [ + "signature", + ".length == " + ], + [ + "without ", + "any " + ], + [ + "EN", + "O" + ], + [ + "into ", + "a single " + ], + [ + "nonReentrant", + "(" + ], + [ + "at least ", + "1 " + ], + [ + "es the ", + "actual " + ], + [ + ");\\n\\n function ", + "get" + ], + [ + "thei", + "r" + ], + [ + "(_msgSender(), ", + "amount" + ], + [ + ", which ", + "can be " + ], + [ + "Public", + "Sale" + ], + [ + "Tokens ", + "> " + ], + [ + "return true", + ";\\n } else {\\n return " + ], + [ + "stored ", + "in " + ], + [ + ",\\r\\n uint256 ", + "amount\\r\\n " + ], + [ + "////////////////////////////////////////////////", + "////////" + ], + [ + "} from \\\"", + "../" + ], + [ + "construction", + ", since the code is only stored at the end" + ], + [ + "toString", + "(" + ], + [ + "Withdraw", + "n" + ], + [ + "root ", + "of the " + ], + [ + "Cach", + "e the " + ], + [ + "decrement", + "ing then " + ], + [ + "da", + "o" + ], + [ + ", \\\"SafeMath: ", + "multiplication overflow" + ], + [ + ", \\\"SafeMath: ", + "addition overflow" + ], + [ + "() external view returns (address", + ");\\n function " + ], + [ + "hand", + "l" + ], + [ + "balances ", + "is capp" + ], + [ + ").div(", + "100" + ], + [ + "futu", + "re " + ], + [ + "compil", + "er " + ], + [ + "_initializ", + "ing" + ], + [ + "uint24 ", + "extraData" + ], + [ + "FI", + "ELD" + ], + [ + "itself", + ", " + ], + [ + "keep", + " in mind " + ], + [ + ", which returns 0", + " for contracts " + ], + [ + "registerAnd", + "Subscribe" + ], + [ + "clas", + "s of " + ], + [ + "Addition ", + "cannot overflow.\\n */\\n function " + ], + [ + "move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to", + "`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this " + ], + [ + "c / a == b", + ", \\\"SafeMath: multiplication overflow" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall", + "(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {" + ], + [ + "the sum of all ", + "balances is capp" + ], + [ + "ed by totalSupply, and the ", + "sum is preser" + ], + [ + "move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this ", + "token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId" + ], + [ + "the sum of all balances is capp", + "ed by totalSupply, and the sum is preser" + ], + [ + "the sum of all balances is capped by totalSupply, and the sum is preser", + "ved by" + ], + [ + "\"", + "pragma solidity ^" + ], + [ + "\"", + "bytecode" + ], + [ + "(", + "approvedAddress" + ], + [ + ".", + "\\n * @param " + ], + [ + "1", + " for " + ], + [ + "3", + "\\n// Creator: Chiru Labs\\n\\npragma solidity ^0.8.4" + ], + [ + "A", + "LE" + ], + [ + "P", + "UBLIC" + ], + [ + "S", + "LOAD" + ], + [ + "t", + "mp" + ], + [ + "y", + ") internal pure returns (" + ], + [ + "in", + "\\n // " + ], + [ + ") ", + "virtual " + ], + [ + ") ", + "returns (bool" + ], + [ + "ic", + "e " + ], + [ + "amount", + ".mul(" + ], + [ + "\\\"", + ");\\n }\\n\\n function " + ], + [ + "address ", + "data " + ], + [ + "er ", + "contract" + ], + [ + "Tr", + "ade" + ], + [ + " = ", + "false" + ], + [ + ",\\n ", + "bytes32[] memory " + ], + [ + "..", + "255" + ], + [ + "only", + "Admin" + ], + [ + "0000", + " " + ], + [ + "0.", + "0" + ], + [ + ";\\n\\n", + "// " + ], + [ + "on ", + "a " + ], + [ + "this ", + "point " + ], + [ + "0x", + "f" + ], + [ + "will ", + "always " + ], + [ + ",\\n address ", + "spender,\\n uint256 value" + ], + [ + "utils/", + "SafeERC20" + ], + [ + "ON", + "ENT" + ], + [ + "Hash", + "\"" + ], + [ + "result", + ", " + ], + [ + "\\r\\n }", + "\\r\\n " + ], + [ + "ref", + "e" + ], + [ + "Solidity", + "\\u0027" + ], + [ + "vari", + "able " + ], + [ + "token/ERC20/", + "utils/SafeERC20" + ], + [ + "For ", + "more " + ], + [ + ")\\n ", + "mstore(" + ], + [ + "modul", + "es/" + ], + [ + "AccessControl", + "Enumerable" + ], + [ + "packedOwnership", + "s[tokenId" + ], + [ + "operation ", + "overflow" + ], + [ + "we", + "b" + ], + [ + "Ar", + "t " + ], + [ + "a / ", + "b;\\n }\\n\\n /**\\n * @dev Returns the " + ], + [ + "_B", + "E" + ], + [ + "calcul", + "ate the " + ], + [ + "increment", + " the " + ], + [ + "Mask", + " of all " + ], + [ + "[to", + "]." + ], + [ + "snapshot", + "s" + ], + [ + "time ", + "of " + ], + [ + "App", + "end" + ], + [ + "char", + "ity" + ], + [ + " bits ", + "for `" + ], + [ + ", \\\"SafeMath: ", + "subtraction overflow" + ], + [ + " is Context", + ", ERC165" + ], + [ + "during ", + "contract " + ], + [ + ") - 1", + ";\\n\\n // The bit position of `" + ], + [ + ";\\n\\n // The bit ", + "mask" + ], + [ + "need", + "ed to " + ], + [ + "except ", + "through " + ], + [ + "Overflow not possible: ", + "balance " + ], + [ + "b5", + "e1" + ], + [ + "total number of tokens ", + "in existence" + ], + [ + "`tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to", + "` is zero, ``from``'s `tokenId` will be " + ], + [ + "Flash", + "Loan" + ], + [ + "reed", + "ing" + ], + [ + "address signer = ", + "ECDSA.recover" + ], + [ + "OpenSe", + "a" + ], + [ + "checked ", + "above" + ], + [ + "IERC721 {\\n /**\\n * @dev Returns the ", + "token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\"" + ], + [ + "startTokenId + ", + "quantity" + ], + [ + "uint256) {\\n // Counter underflow is impossible ", + "as " + ], + [ + "}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator", + "];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function " + ], + [ + "DelegateVotes", + "Changed" + ], + [ + "When `from` and `to` are both non-zero, ``from``'s ", + "`tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be " + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// ERC721A Contracts v4.2.", + "3\\n// Creator: Chiru Labs\\n\\npragma solidity ^0.8.4" + ], + [ + "ERC721AStorage", + ".layout()." + ], + [ + "IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is ", + "IERC721 {\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\"" + ], + [ + "s with added ", + "overflow" + ], + [ + "Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - ", + "When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be " + ], + [ + "most", + "ly " + ], + [ + ":\\n *\\n * ", + "/^AccessControl: account (0x[0-9a-f]{" + ], + [ + ") public virtual override onlyRole(getRoleAdmin(role)", + ") {\\n _" + ], + [ + "format of the revert reason is given by the following regular expression", + ":\\n *\\n * /^AccessControl: account (0x[0-9a-f]{" + ], + [ + "Addition cannot overflow.\\n */\\n function ", + "add" + ], + [ + "\"bytecode", + "Hash\"" + ], + [ + "..255", + "] `" + ], + [ + "Solidity\\u0027", + "s `" + ], + [ + "Mask of all ", + "256 bits " + ], + [ + " ", + "downcasted) {\\n downcasted = int" + ], + [ + "\"", + "G" + ], + [ + "'", + "," + ], + [ + ")", + ",\\n " + ], + [ + "B", + "id" + ], + [ + "C", + "ut" + ], + [ + "S", + "ingle" + ], + [ + "_", + "PERMIT_TYPEHASH" + ], + [ + "_", + "usd" + ], + [ + "f", + "lo" + ], + [ + "i", + "al " + ], + [ + "s ", + ">= " + ], + [ + "int", + "8" + ], + [ + "th", + "ir" + ], + [ + "ti", + "st " + ], + [ + "in", + "correct " + ], + [ + ", ", + "sub" + ], + [ + "ent", + "ries" + ], + [ + "is", + "or" + ], + [ + "To", + "p" + ], + [ + "` ", + "restore" + ], + [ + "ing ", + "without " + ], + [ + "contract", + "s, " + ], + [ + "In", + "For" + ], + [ + "ERC721", + "TokenReceiver" + ], + [ + "memory", + ", which can be " + ], + [ + "it ", + "alway" + ], + [ + "true", + ", the " + ], + [ + "value ", + "and " + ], + [ + "po", + "s " + ], + [ + "(uint256 ", + "new" + ], + [ + "min", + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a " + ], + [ + ");\\n\\n ", + "_beforeTokenTransfer" + ], + [ + " is ", + "at most " + ], + [ + "Sign", + "ature " + ], + [ + "of", + "f " + ], + [ + "sell", + "Liquidity" + ], + [ + "= _", + "get" + ], + [ + "den", + "omin" + ], + [ + "unchecked ", + "operations " + ], + [ + "quantity", + " * (" + ], + [ + "gener", + "ate" + ], + [ + "https://eips.ethereum.org/EIPS/eip-", + "2098" + ], + [ + "reverting ", + "the transaction " + ], + [ + "stake", + "Id" + ], + [ + "spender, ", + "newAllowance" + ], + [ + "zero.\\n *\\n * ", + "CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {" + ], + [ + "Ver", + "ify" + ], + [ + "Using ", + "this library " + ], + [ + ") public virtual override returns (bool) {\\n ", + "_approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20" + ], + [ + " {\\n /**\\n * @dev Returns the ", + "addition" + ], + [ + "require(b", + " > 0, errorMessage" + ], + [ + "multip", + "lier" + ], + [ + "too ", + "much " + ], + [ + ";\\n\\n ", + "/**\\n * @notice " + ], + [ + ", which is ", + "checked above" + ], + [ + "totalSupply ", + "+ amount" + ], + [ + "a - ", + "b;\\n }\\n\\n /**\\n * @dev Returns the " + ], + [ + "ECDSA: invalid ", + "signature" + ], + [ + "(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted ", + "uint" + ], + [ + "s this ", + "int" + ], + [ + "second", + "ary " + ], + [ + "Enabled = ", + "false" + ], + [ + "operator, approved", + ");\\n }\\n\\n /**\\n * @dev " + ], + [ + "+ amount", + " is at most " + ], + [ + "bugs, ", + "so " + ], + [ + "Tri", + "gg" + ], + [ + "Dig", + "italMedia" + ], + [ + "MintAmount", + "PerTx" + ], + [ + "gobbl", + "er" + ], + [ + "ribu", + "tor" + ], + [ + "on overflow", + ". This " + ], + [ + "individ", + "ual " + ], + [ + "idden", + "MetadataUri" + ], + [ + "str := sub(", + "str" + ], + [ + "Cannot", + "Be" + ], + [ + "[to] += ", + "quantity * (" + ], + [ + "global_collateral_", + "ratio" + ], + [ + "Bank", + "X" + ], + [ + "benefit is lost if 'b' is also test", + "ed" + ], + [ + "did not ", + "succeed" + ], + [ + "recommended to use ", + "it alway" + ], + [ + "instead of the ", + "unchecked operations " + ], + [ + "elimin", + "ates an " + ], + [ + "At(address registrant, uint256 index", + ") external returns (" + ], + [ + "class of ", + "bugs, so " + ], + [ + "a / b;\\n }\\n\\n /**\\n * @dev Returns the ", + "remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting " + ], + [ + "Overflow not possible: balance ", + "+ amount is at most " + ], + [ + "b5e1", + "39f" + ], + [ + "` restore", + "s this int" + ], + [ + "reverting the transaction ", + "when " + ], + [ + "Using this library ", + "instead of the unchecked operations " + ], + [ + "totalSupply + amount", + ", which is checked above" + ], + [ + "eliminates an ", + "entire" + ], + [ + "Overflow not possible: balance + amount is at most ", + "totalSupply + amount, which is checked above" + ], + [ + "Using this library instead of the unchecked operations ", + "eliminates an entire" + ], + [ + "#", + "((" + ], + [ + ".", + "\\n * " + ], + [ + "V", + "ot" + ], + [ + "_", + "p" + ], + [ + "_", + "cap" + ], + [ + "s ", + "owned by " + ], + [ + "on", + "\"" + ], + [ + "\\n ", + ")\\n {\\n " + ], + [ + "the ", + "signature " + ], + [ + "ent", + "ly " + ], + [ + "qu", + "ite " + ], + [ + "ver", + "s" + ], + [ + "owner", + ".\\n // - `startTimestamp` to the timestamp of " + ], + [ + ": ", + "Cannot " + ], + [ + " ", + "// If the next slot is within bounds." + ], + [ + "\\n\\n", + "/**\\n * @dev " + ], + [ + "--", + "- " + ], + [ + "not ", + "the " + ], + [ + "Amount", + " of " + ], + [ + ");\\n", + "\\n uint256 " + ], + [ + "if (", + "ownership.addr != address(0)" + ], + [ + "cl", + "ass" + ], + [ + "will ", + "not be " + ], + [ + "tim", + "es " + ], + [ + "string memory ", + "_name" + ], + [ + "buy", + "Liquidity" + ], + [ + "Fees", + "[0" + ], + [ + "))", + ");\\r\\n " + ], + [ + "s to ", + "the " + ], + [ + "....", + ".." + ], + [ + " <", + "0.9.0" + ], + [ + "stor", + "ing the " + ], + [ + ", amount", + "s" + ], + [ + "Operator", + "Not" + ], + [ + "present", + ".\\n */\\n function _" + ], + [ + "MIN", + "ATOR" + ], + [ + "mut", + "ability " + ], + [ + "<= ", + "totalSupply" + ], + [ + "26", + "91" + ], + [ + "functions ", + "marked " + ], + [ + "packed ", + "= (" + ], + [ + "defin", + "ition" + ], + [ + "withdraw", + " " + ], + [ + "mess", + "ag" + ], + [ + "uint64", + " _" + ], + [ + "s[tokenId", + "]." + ], + [ + "comp", + "ound " + ], + [ + " of two unsigned integers, ", + "reverting on\\n * overflow (when the " + ], + [ + "distribu", + "tor" + ], + [ + "dif", + "fer" + ], + [ + "}\\n\\n // ", + "Underflow of the sender's balance is impossible because we check for\\n // ownership above and the recipient's balance can't realistically overflow.\\n // Counter overflow is incredibly unrealistic as " + ], + [ + "making ", + "it " + ], + [ + "MaxWallet", + "Limit" + ], + [ + "Copy", + "Entries" + ], + [ + ", uint256 index", + ") internal view returns (" + ], + [ + "mapping (address => ", + "uint256" + ], + [ + "It is ", + "possible to " + ], + [ + "random", + " " + ], + [ + ");\\n\\n ", + "_currentIndex = " + ], + [ + "false ", + "otherwise" + ], + [ + ";\\r\\n ", + "}\\r\\n " + ], + [ + "state ", + "mutability " + ], + [ + "ence ", + "state mutability " + ], + [ + " == 0) {\\n ", + "uint256 nextTokenId = tokenId + 1" + ], + [ + "Comput", + "e " + ], + [ + "transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ", + ") public virtual override {\\n " + ], + [ + "obta", + "in the " + ], + [ + "signific", + "ant" + ], + [ + "Fees[", + "1" + ], + [ + "for each ", + "mint" + ], + [ + "total number of tokens ", + "minted" + ], + [ + "`hash", + "es" + ], + [ + "\\\\ ", + "\\\\" + ], + [ + ".\\n if (", + "prevOwnershipPacked " + ], + [ + "(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n require(b", + " > 0, errorMessage" + ], + [ + "_packedOwnerships[nextTokenId", + "] == 0) {\\n " + ], + [ + "registerAnd", + "CopyEntries" + ], + [ + "Updates:\\n // - `address", + "` to the " + ], + [ + "name, ", + "symbol" + ], + [ + "rend", + "er the " + ], + [ + ";\\n }\\n\\n /**\\n * @dev Returns the subtraction", + " of two unsigned integers, reverting on\\n * overflow (when the " + ], + [ + "Fail", + "ed(" + ], + [ + "iter", + "al" + ], + [ + "DELEG", + "ATION_TYPEHASH" + ], + [ + "_FE", + "E_PERCENT" + ], + [ + "_startTokenId();\\n ", + "}\\n }\\n\\n /**\\n * @dev Returns the " + ], + [ + ",\\n uint256[] memory balances", + ",\\n uint256 " + ], + [ + ";\\n // ", + "If the next slot's address is zero and not burned (i.e. packed value is zero)." + ], + [ + "String operations.\\n */\\nlibrary Strings {\\n bytes16 private constant _HEX_SYMBOLS = \\\"0123456789abcdef", + "\\\"" + ], + [ + "relev", + "ant " + ], + [ + "delete _tokenApprovals[tokenId", + "]" + ], + [ + "warn", + "ing without " + ], + [ + "bur", + "nt" + ], + [ + "nest", + "ed " + ], + [ + "\\n *\\n * Requirements:\\n *", + "\\n * - `" + ], + [ + ") {\\n // ", + "Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`." + ], + [ + "auxili", + "ary data for `owner`. (e.g. number of whitelist mint slots used" + ], + [ + "recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer", + "(_msgSender(), recipient, amount" + ], + [ + "If the next slot may not have been initialized (i.e. `nextInitialized == false`) ", + ".\\n if (prevOwnershipPacked " + ], + [ + "Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the ", + "Metadata extension" + ], + [ + "_packedOwnerships[nextTokenId] = prevOwnershipPacked;", + "\\n }\\n }\\n }\\n " + ], + [ + "ENO", + "MINATOR" + ], + [ + "return true;\\n } else {\\n return ", + "false;\\n }\\n }\\n\\n /**\\n * @dev " + ], + [ + ",\\n address spender,\\n uint256 value", + "\\n ) internal {\\n " + ], + [ + " // If the next slot is within bounds.", + "\\n " + ], + [ + "ence state mutability ", + "warning without " + ], + [ + " == 0) {\\n uint256 nextTokenId = tokenId + 1", + ";\\n // If the next slot's address is zero and not burned (i.e. packed value is zero)." + ], + [ + "_packedOwnerships[nextTokenId] == 0) {\\n ", + " // If the next slot is within bounds.\\n " + ], + [ + ";\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the ", + "result is negative" + ], + [ + ") {\\n // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.", + "\\n " + ], + [ + "ence state mutability warning without ", + "generating " + ], + [ + " == 0) {\\n uint256 nextTokenId = tokenId + 1;\\n // If the next slot's address is zero and not burned (i.e. packed value is zero).", + "\\n if (" + ], + [ + "(", + ")\\n " + ], + [ + "(", + ") internal view " + ], + [ + "(", + "digest" + ], + [ + ")", + "` is " + ], + [ + "-", + "> " + ], + [ + "@", + "member " + ], + [ + "C", + "OL" + ], + [ + "D", + "OMAIN" + ], + [ + "N", + "_CO" + ], + [ + "_", + "bytes" + ], + [ + "c", + "ash" + ], + [ + "i", + "h" + ], + [ + "j", + "u" + ], + [ + "|", + "= " + ], + [ + "en", + "cy " + ], + [ + ", ", + "gt(" + ], + [ + "un", + "locked" + ], + [ + "ex", + "change " + ], + [ + "amount", + " to " + ], + [ + "Token", + "." + ], + [ + " ", + "IERC721Metadata" + ], + [ + "account", + ", " + ], + [ + "transfer", + "Fee" + ], + [ + "an ", + "un" + ], + [ + "(address ", + "_owner" + ], + [ + "set", + "Max" + ], + [ + ";\\n ", + "bool " + ], + [ + "\\r\\n", + "\\r\\n " + ], + [ + "by ", + "setting " + ], + [ + "mint", + "ing.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `" + ], + [ + "Rol", + "e " + ], + [ + "bytes32 ", + "digest " + ], + [ + "IP", + "IENT" + ], + [ + "(\\n address ", + "_" + ], + [ + "SafeMath", + " {\\n /**\\n * @dev Returns the addition" + ], + [ + "fee", + "s = " + ], + [ + "Burn", + "able is " + ], + [ + "Not", + "Paused(" + ], + [ + "Del", + "ta" + ], + [ + "\"@openzeppelin/contracts/", + "token/ERC721/extensions/IERC721Metadata.sol\"" + ], + [ + "marketing", + "Tax" + ], + [ + ";\\n\\n // ", + "Mask of all 256 bits " + ], + [ + "address,", + "uint" + ], + [ + ") internal view virtual ", + "returns (bool) {\\n return " + ], + [ + ";\\n ", + "}\\n " + ], + [ + ";\\n ", + "}\\n " + ], + [ + ".\\n */\\n", + "contract " + ], + [ + ") / ", + "2 " + ], + [ + "no ", + "data" + ], + [ + "Block", + "s" + ], + [ + "tokenId ", + "< _" + ], + [ + "_total", + "Fees" + ], + [ + "$$", + " " + ], + [ + " ", + "IERC165" + ], + [ + "inh", + "eriting " + ], + [ + "sqrt", + "Ratio" + ], + [ + "(address(0), to, ", + "updatedIndex" + ], + [ + "equ", + "al " + ], + [ + "descri", + "ption" + ], + [ + "_packedOwnership", + "Of" + ], + [ + "WARNING: ", + "This " + ], + [ + "Transfer(address indexed from, address indexed to, uint256 ", + "value" + ], + [ + "\\n // - ", + "[0.." + ], + [ + "computedHash", + " = " + ], + [ + ".safeTransfer", + "(" + ], + [ + "get the ", + "total number of tokens minted" + ], + [ + "reduce the ", + "count" + ], + [ + "NOT_ENTERED", + " = 1" + ], + [ + "An ", + "event " + ], + [ + "`.\\n // - `", + "numberMinted += quantity" + ], + [ + ")\\n external\\n ", + "payable" + ], + [ + "uint160(", + "addr" + ], + [ + "> 0) {\\n ", + "return " + ], + [ + "ZERO", + "_ADDRESS" + ], + [ + "(\\n address owner,\\n address spender,\\n uint256 amount\\n ", + ") internal virtual {\\n uint256 currentAllowance = allowance(owner, spender);\\n if (currentAllowance != type(uint256).max) {\\n require(currentAllowance >= amount, \\\"ERC20: insufficient allowance\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - amount);\\n }\\n }\\n }\\n\\n /**\\n * @dev " + ], + [ + "keccak256(bytes(", + "name" + ], + [ + "factor", + "y " + ], + [ + "IERC721Receiver(to).", + "onERC721Received.selector" + ], + [ + "_totalSupply -= ", + "amount;\\n\\n emit Transfer" + ], + [ + "`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked", + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to " + ], + [ + "+= quantity", + "`.\\n // - `numberMinted += quantity" + ], + [ + "Burned ", + "tokens will " + ], + [ + "ENTERED", + " = 2" + ], + [ + ".\\n // - `startTimestamp` to the timestamp of ", + "minting.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `" + ], + [ + "Updates:\\n // - `address", + "` to the owner" + ], + [ + "dynam", + "ic" + ], + [ + ". Al", + "so " + ], + [ + "fra", + "x_" + ], + [ + "s = 0", + ";\\n uint256 " + ], + [ + "`.\\n //\\n // We can directly ", + "add to the " + ], + [ + ".\\n // ", + "The " + ], + [ + "Address for address;\\n using ", + "Strings for uint256" + ], + [ + "\"_transfer:: Transfer Delay enabled. ", + "Only one purchase " + ], + [ + "freeMemory", + "Pointer" + ], + [ + "(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll", + "}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function " + ], + [ + "Bits Layout:", + "\\n // - [0.." + ], + [ + "of `tokenId", + "`.\\n */\\n function _" + ], + [ + "BITPOS_NUMBER_MINTED) | 1", + ");\\n\\n // " + ], + [ + "next token ID", + " to be minted" + ], + [ + "recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount", + ");\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-" + ], + [ + "get the total number of tokens minted", + ", please " + ], + [ + "+= quantity`.\\n // - `numberMinted += quantity", + "`.\\n //\\n // We can directly add to the " + ], + [ + "Burned tokens will ", + "reduce the count" + ], + [ + ".\\n // - `startTimestamp` to the timestamp of minting.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `", + "quantity == 1" + ], + [ + "Updates:\\n // - `address` to the owner", + ".\\n // - `startTimestamp` to the timestamp of minting.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `quantity == 1" + ], + [ + "\"_transfer:: Transfer Delay enabled. Only one purchase ", + "per block allowed.\"" + ], + [ + "\"", + "Amount " + ], + [ + "\"", + "Insufficient " + ], + [ + ".", + "WETH" + ], + [ + "1", + " - " + ], + [ + "2", + "-" + ], + [ + "5", + "._" + ], + [ + "D", + "C" + ], + [ + "O", + "FFSET" + ], + [ + "_", + "at" + ], + [ + "_", + " = " + ], + [ + "_", + "require(" + ], + [ + "`", + "msgSender" + ], + [ + "`", + "msg.sender" + ], + [ + "a", + "2" + ], + [ + "j", + "ect to " + ], + [ + "u", + "s the " + ], + [ + "x", + "n" + ], + [ + "\\n", + "*/\\n function " + ], + [ + "e ", + "to " + ], + [ + "s ", + "may " + ], + [ + "in", + "clude " + ], + [ + "at", + "ed by " + ], + [ + "\\\"", + "main " + ], + [ + "function ", + "may " + ], + [ + "20", + "+ " + ], + [ + "call", + " the " + ], + [ + "if", + "s save " + ], + [ + ");\\n ", + "}\\n return " + ], + [ + "for ", + "(uint " + ], + [ + "if ", + "approvedAddress " + ], + [ + "par", + "ti" + ], + [ + "red", + "und" + ], + [ + "max", + "Wallet " + ], + [ + "The ", + "divisor cannot be " + ], + [ + "uniswapV2", + "Router " + ], + [ + "buy", + "er" + ], + [ + "data ", + "version of {" + ], + [ + "If ", + "there are " + ], + [ + "64", + "})$/" + ], + [ + "██", + "╗" + ], + [ + ");\\n ", + "} else {\\n " + ], + [ + ".\\n ", + "return (" + ], + [ + "St", + "ash" + ], + [ + ", bool ", + "filtered" + ], + [ + "gas ", + "over a " + ], + [ + "< ", + "stop" + ], + [ + "AccessControl", + "-" + ], + [ + "? ", + "leaves[" + ], + [ + "ful", + "ly " + ], + [ + "40", + "}) is missing role (0x[0-9a-f]{" + ], + [ + "ownership ", + "data " + ], + [ + ") {\\n return _", + "unpackedOwnership" + ], + [ + "boole", + "an" + ], + [ + ");\\r\\n }\\r\\n", + "\\r\\n /**\\r\\n * @dev Returns the " + ], + [ + "boolean ", + "condition" + ], + [ + ".sol\\\";\\n\\n", + "interface " + ], + [ + "leaf", + "Pos++] : " + ], + [ + "extraData", + "Casted " + ], + [ + ") {\\n _", + "require" + ], + [ + "on\\n * overflow", + " (when the result is negative" + ], + [ + ".sol\\\";\\nimport \\\"../../", + "utils/introspection/ERC165.sol\\\";\\n\\n/**\\n * @dev " + ], + [ + ");\\r\\n\\r\\n ", + "// " + ], + [ + "(to, ", + "amount" + ], + [ + "\\n uint256 ", + "size" + ], + [ + "maximum ", + "limit of " + ], + [ + "them ", + "into a " + ], + [ + "bound", + "ed " + ], + [ + "around ", + "20+ " + ], + [ + ".\\n *\\n * Emits a {Transfer} event ", + "for each mint" + ], + [ + "accountBalance ", + "<= totalSupply" + ], + [ + "get the ", + "next " + ], + [ + "` with ", + "assembly to avoid " + ], + [ + "extra ", + "SLOAD" + ], + [ + "two numbers", + ". The result is rounded toward" + ], + [ + "totalHash", + "es " + ], + [ + "approvedAddressSlot", + ", 0" + ], + [ + ")\\n internal", + "\\n pure" + ], + [ + "(address sender, address recipient, uint256 amount", + ") external returns (bool" + ], + [ + "Pos++", + "];\\n " + ], + [ + "eq(", + "msgSender" + ], + [ + "ZZZZZZZZZZZZZZZZ", + "ZZZZZZZZZZZZZZZZ" + ], + [ + ".length == ", + "0) {\\n " + ], + [ + "amount <= ", + "accountBalance <= totalSupply" + ], + [ + ", so we ", + "distribute" + ], + [ + "wra", + "p " + ], + [ + "Kee", + "p " + ], + [ + "Vi", + "ew" + ], + [ + "hashes[", + "hash" + ], + [ + "extraData = ", + "uint24(" + ], + [ + "leavesLen ", + "? leaves[" + ], + [ + " of two unsigned integers, reverting with custom message ", + "on\\n * overflow (when the result is negative" + ], + [ + "s < ", + "leavesLen ? leaves[" + ], + [ + "\\r\\n /**\\r\\n * ", + "@dev " + ], + [ + "TokenOwnership memory", + ") {\\n return _unpackedOwnership" + ], + [ + "pack ", + "them into a " + ], + [ + "nextInitializedFlag", + "(quantity" + ], + [ + "IERC721Receiver(to).onERC721Received", + "(_msgSender(), " + ], + [ + "Consum", + "er" + ], + [ + "sstore(", + "approvedAddressSlot, 0" + ], + [ + "This is equivalent to `", + "delete _tokenApprovals[tokenId]" + ], + [ + "isApprovedForAll(from, ", + "_msgSenderERC721A())" + ], + [ + "leafPo", + "s < leavesLen ? leaves[" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\\n * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\\n * by default", + ", can be " + ], + [ + "EnumerableSet ", + "for " + ], + [ + "minut", + "es" + ], + [ + "Paramet", + "er" + ], + [ + ";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = _HEX_SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer", + ");\\n }\\n}\\n\"" + ], + [ + ")\\r\\n external", + "\\r\\n " + ], + [ + "Multiplication ", + "cannot overflow.\\n */\\n function " + ], + [ + "extra data ", + "for the " + ], + [ + "effectivel", + "y " + ], + [ + "Rig", + "id" + ], + [ + "Squ", + "eeth" + ], + [ + "{Transfer} event", + "(" + ], + [ + "compound ", + "boolean condition" + ], + [ + "nested ", + "ifs save " + ], + [ + "_packedOwnerships[nextTokenId] = prevOwnershipPacked;\\n }\\n }\\n }\\n ", + "}\\n\\n emit Transfer" + ], + [ + ") / 2 ", + "can overflow" + ], + [ + "\\\"main ", + "queue" + ], + [ + "redund", + "ant " + ], + [ + "The divisor cannot be ", + "zero" + ], + [ + "gas over a ", + "compound boolean condition" + ], + [ + "40}) is missing role (0x[0-9a-f]{", + "64})$/" + ], + [ + "leafPos++] : ", + "hashes[hash" + ], + [ + "around 20+ ", + "gas over a compound boolean condition" + ], + [ + "` with assembly to avoid ", + "redundant " + ], + [ + "leafPos < leavesLen ? leaves[", + "leafPos++] : hashes[hash" + ], + [ + "nested ifs save ", + "around 20+ gas over a compound boolean condition" + ], + [ + ".", + "openzeppelin.com/" + ], + [ + "0", + ")" + ], + [ + "F", + "r" + ], + [ + "I", + "RE" + ], + [ + "_", + " " + ], + [ + "v", + "rf" + ], + [ + "z", + "ro" + ], + [ + ", ", + "\\u0027" + ], + [ + "\\\"", + ");\\n }\\n\\n /**\\n * @dev Returns the " + ], + [ + ") {", + "\\r\\n " + ], + [ + "Re", + "f " + ], + [ + "call", + " is not " + ], + [ + "(address ", + "_to" + ], + [ + ") internal ", + "onlyInitializ" + ], + [ + "from ", + "another " + ], + [ + "contract ", + "address" + ], + [ + "max", + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a " + ], + [ + "The ", + "nested ifs save around 20+ gas over a compound boolean condition" + ], + [ + "with ", + "no " + ], + [ + "this ", + "imp" + ], + [ + "this ", + "from " + ], + [ + "@@@@", + "@@@" + ], + [ + "Del", + "ight" + ], + [ + "but ", + "in " + ], + [ + "sibl", + "ing " + ], + [ + ");\\n ", + "require(" + ], + [ + "if the ", + "target address " + ], + [ + ";\\n ", + "}\\n }\\n " + ], + [ + "Dev", + "elopers " + ], + [ + "spec", + "ial" + ], + [ + "project", + "Id " + ], + [ + "call to ", + "nonReentrant" + ], + [ + " = _", + "startTokenId" + ], + [ + "(msg.sender", + ", amount" + ], + [ + "ERC20 ", + "token " + ], + [ + "_check", + "FilterOperator" + ], + [ + "via ", + "the " + ], + [ + "35", + "25" + ], + [ + "bas", + "ic" + ], + [ + "Fin", + "ance" + ], + [ + "specifi", + "ed" + ], + [ + "sal", + "es" + ], + [ + "ffffffffffffffff", + "ffffffff" + ], + [ + "Signed", + "Math" + ], + [ + "ident", + "ifier " + ], + [ + "IL", + "ayerZero" + ], + [ + " = new ", + "address[](" + ], + [ + "multiple ", + "variables" + ], + [ + "do ", + "{\\n " + ], + [ + "() public ", + "pure returns (" + ], + [ + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n ", + "uint256 c = a + b" + ], + [ + "set of ", + "permission" + ], + [ + ".\\r", + "\\n *\\r\\n * " + ], + [ + "Ptr", + ", " + ], + [ + "(address addr", + ") internal pure returns (" + ], + [ + "//\\n//", + " " + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7", + ".0) (utils/" + ], + [ + ";\\n }\\n\\n /**\\n * @dev See {IERC721Metadata", + "-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (" + ], + [ + "_LENGTH", + " = 20" + ], + [ + "leavesL", + "en" + ], + [ + ", please ", + "pack them into a " + ], + [ + "lik", + "el" + ], + [ + "\\\"H", + "ack" + ], + [ + ")), ", + "_ADDRESS_LENGTH" + ], + [ + "Lz", + "App" + ], + [ + "ADDRESS", + "_LENGTH = 20" + ], + [ + ") ||", + " (" + ], + [ + "toHexString(uint256(", + "uint160(addr" + ], + [ + "executed ", + "if the target address " + ], + [ + "in\\n // ", + "construction, since the code is only stored at the end" + ], + [ + ".swap", + "Exact" + ], + [ + "uint8 private constant _", + "ADDRESS_LENGTH = 20" + ], + [ + "\\n }\\n ", + "packed = (" + ], + [ + "return\\n interfaceId == type(", + "IERC721" + ], + [ + "sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ", + "``sender``'s " + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer", + "(\\n address from,\\n address to,\\n uint256 tokenId\\n " + ], + [ + "Minim", + "al" + ], + [ + "when dividing by zero.\\n *\\n * Counterpart to Solidity's `", + "%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod" + ], + [ + ", which returns 0 for contracts ", + "in\\n // construction, since the code is only stored at the end" + ], + [ + "BITPOS_NUMBER_MINTED) | 1);\\n\\n // ", + "Updates:\\n // - `address` to the owner.\\n // - `startTimestamp` to the timestamp of minting.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `quantity == 1" + ], + [ + "If there are ", + "multiple variables" + ], + [ + "Multiplication cannot overflow.\\n */\\n function ", + "mul" + ], + [ + "call is not ", + "executed if the target address " + ], + [ + "toHexString(uint256(uint160(addr", + ")), _ADDRESS_LENGTH" + ], + [ + "sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s ", + "tokens of at least\\n * `amount`.\\n */\\n function transferFrom" + ], + [ + ", which returns 0 for contracts in\\n // construction, since the code is only stored at the end", + " of the\\n // " + ], + [ + "If there are multiple variables", + ", please pack them into a " + ], + [ + "call is not executed if the target address ", + "is not " + ], + [ + "\"", + "useL" + ], + [ + "-", + "level " + ], + [ + ".", + ":" + ], + [ + ".", + "proxy." + ], + [ + "1", + "]" + ], + [ + "3", + " * " + ], + [ + "@", + "inheritdoc " + ], + [ + "F", + "ilte" + ], + [ + "N", + "ow " + ], + [ + "_", + "OPERATOR_FILTER_REGISTRY" + ], + [ + "_", + "modules/" + ], + [ + "a", + "v" + ], + [ + " ", + "| " + ], + [ + "on", + "e. " + ], + [ + "un", + "callable if the " + ], + [ + "un", + "bounded " + ], + [ + "//", + "solhint-disable-next-line max-line-length\\n require(" + ], + [ + ") ", + "|| " + ], + [ + "end", + " = " + ], + [ + "ed ", + "ASCII `string` " + ], + [ + "` ", + "function that " + ], + [ + "owner", + " == address(0)) revert " + ], + [ + "of ", + "data " + ], + [ + ".\\n *\\n * ", + "May emit a {Role" + ], + [ + "- ", + "see https://github.com/ethereum/solidity/issues/" + ], + [ + "external", + ", and " + ], + [ + "es ", + "too much " + ], + [ + ") {\\n ", + "(bool success, bytes memory returndata) = target" + ], + [ + "not ", + "check" + ], + [ + "view ", + "accessor" + ], + [ + "it ", + "as part of a " + ], + [ + "memory ", + "consum" + ], + [ + " of ", + "20 bytes " + ], + [ + "true", + "`.\\n _" + ], + [ + "value ", + "once " + ], + [ + "(uint256 ", + "approvedAddressSlot, address approvedAddress" + ], + [ + "token ", + "in the " + ], + [ + "this", + "; // " + ], + [ + "Call", + "ing a " + ], + [ + "(\\n ", + "bytes32[] memory proof" + ], + [ + "\\n // ", + "currently is to use assembly" + ], + [ + "will ", + "copy the " + ], + [ + ") {\\n ", + "bytes32 r" + ], + [ + "and", + "\\n // " + ], + [ + "private", + "` function that " + ], + [ + ";\\n ", + "mapping(uint256 => " + ], + [ + "do", + "es the actual " + ], + [ + "On", + "e" + ], + [ + "On", + " the first " + ], + [ + "red ", + "(see" + ], + [ + ");\\n\\n /**\\n * @dev ", + "Returns a token ID " + ], + [ + "\\n */", + "\\n\\n" + ], + [ + "since ", + "no data" + ], + [ + "Interfac", + "e(" + ], + [ + "set ", + "in an " + ], + [ + "set ", + "grow" + ], + [ + "typ", + "e that " + ], + [ + ".\\n * ", + "Burned tokens will reduce the count" + ], + [ + "is not ", + "supported. " + ], + [ + "using ", + "it as part of a " + ], + [ + "\\n\\t\\t", + "// " + ], + [ + ", and ", + "using it as part of a " + ], + [ + ");\\n\\t", + "\\t" + ], + [ + "() external view returns (", + "uint);\\n function " + ], + [ + "s a ", + "contract from " + ], + [ + "Mo", + "ves " + ], + [ + "safeTransferFrom", + "}" + ], + [ + "should ", + "keep in mind " + ], + [ + "update", + "MaxWalletAmount" + ], + [ + "Rate", + "Provider" + ], + [ + "1 ", + "{" + ], + [ + "ing the ", + "`nonReentrant` function " + ], + [ + "\\n *\\n * ", + "WARNING: This " + ], + [ + "gas ", + "fees. " + ], + [ + "https://eips.ethereum.org/EIPS/eip-", + "22" + ], + [ + ")\\n ", + ");\\n\\n // " + ], + [ + "approved ", + "query for nonexistent token" + ], + [ + "ful", + "fillRandom" + ], + [ + "_buy", + "MarketingFee" + ], + [ + "Delegate", + "Changed" + ], + [ + "Or", + "der" + ], + [ + "operation ", + "will copy the " + ], + [ + "array", + "\\n *\\n * WARNING: This " + ], + [ + "this function ", + "has an " + ], + [ + "safeMint", + "(address to, uint256 tokenId" + ], + [ + "(0x", + "7" + ], + [ + ") external view returns (uint256", + ");\\n}\\n\"" + ], + [ + "currentAllowance ", + "- amount" + ], + [ + "Public", + "Drop" + ], + [ + "after ", + "this point " + ], + [ + "wei", + "Value" + ], + [ + "where ", + "copy" + ], + [ + "} that ", + "allows " + ], + [ + ") {\\n return ", + "(address(0), RecoverError.InvalidSignature" + ], + [ + "fit in ", + "a block" + ], + [ + ",\\n \\\"", + "ERC721: " + ], + [ + "calling ", + "itself, " + ], + [ + "ing to ", + "memory consum" + ], + [ + "query ", + "the " + ], + [ + "prevent ", + "this from " + ], + [ + "calls to ", + "nonReentrant " + ], + [ + ". This is ", + "design" + ], + [ + "ownership.", + "burned " + ], + [ + "cost", + ", and using it as part of a " + ], + [ + "By ", + "storing the " + ], + [ + "Protocol", + "Fees" + ], + [ + "(\\n address from,\\n address to,\\n uint256 amount\\n ", + ") internal virtual {\\n require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(to != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, amount);\\n\\n uint256 fromBalance = _balances[from];\\n require(fromBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n unchecked {\\n _balances[from] = fromBalance - amount" + ], + [ + "again", + ", a " + ], + [ + "division", + " of " + ], + [ + "set, ", + "value" + ], + [ + ";\\n // ", + "Cast " + ], + [ + "Return the ", + "entire " + ], + [ + "`nonReentrant", + "`" + ], + [ + "point ", + "where copy" + ], + [ + "would ", + "like " + ], + [ + "))\\n ", + "v" + ], + [ + "Returns an ", + "array of " + ], + [ + "toInt", + "256" + ], + [ + "squ", + "are" + ], + [ + "free", + "ze" + ], + [ + ") - 1", + ";\\n\\n // The " + ], + [ + "() external pure returns (", + "string memory" + ], + [ + "` with ", + "fixed length" + ], + [ + ";\\n // ", + "ecrecover takes the signature parameters, and the only way to get them" + ], + [ + "ampl", + "es" + ], + [ + "original ", + "value once " + ], + [ + "entire ", + "storage to " + ], + [ + "refund ", + "is trigge" + ], + [ + "vesting", + "Round" + ], + [ + "(0, ", + "since no data" + ], + [ + "that\\n * ", + "this function has an " + ], + [ + "node", + "_modules/" + ], + [ + "Exp", + "ir" + ], + [ + "Prevent", + "s a contract from " + ], + [ + "in the set. O(1).\\n */\\n function ", + "length(" + ], + [ + "Equivalent to `", + "safeTransferFrom(from, to, tokenId, ''" + ], + [ + "keccak256(abi.encodePacked(\\\"\\\\x19", + "\\\\x01" + ], + [ + ");\\n\\n // Clear approvals from the previous owner", + ".\\n assembly {\\n " + ], + [ + "\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.6.0 <0.8.0", + ";\\n\\n/**\\n * @dev " + ], + [ + "0x5", + "b5e139f" + ], + [ + "constructor execution.\\n", + "\\n uint256 size" + ], + [ + "propor", + "tion" + ], + [ + "tokensOfOwner", + "In" + ], + [ + "`.\\n ", + "sstore(approvedAddressSlot, 0" + ], + [ + "OpenSe", + "a " + ], + [ + "\\n\\t *\\n\\t * ", + "@dev " + ], + [ + "`nonReentrant` function ", + "from another " + ], + [ + "packed & _BITMASK", + "_BURNED" + ], + [ + "of two numbers.\\n */\\n function ", + "min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a " + ], + [ + "to its ", + "not check" + ], + [ + "by mak", + "ing the `nonReentrant` function " + ], + [ + "queried ", + "without any " + ], + [ + "Allowance = ", + "token.allowance(address(this), spender" + ], + [ + "Overri", + "de" + ], + [ + "`address", + "` with fixed length" + ], + [ + ")\\n }\\n ", + "}\\n\\n // Underflow of the sender's balance is impossible because we check for\\n // ownership above and the recipient's balance can't realistically overflow.\\n // Counter overflow is incredibly unrealistic as " + ], + [ + "s that are ", + "queried without any " + ], + [ + "Any ", + "calls to nonReentrant " + ], + [ + "bytecode ", + "- see https://github.com/ethereum/solidity/issues/" + ], + [ + "Content", + "\"" + ], + [ + "sil", + "ence state mutability warning without generating " + ], + [ + "Casted", + ";\\n // Cast " + ], + [ + "_36", + "_" + ], + [ + "Inh", + "eriting " + ], + [ + ") | _nextExtraData", + "(address(0), to, " + ], + [ + "on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `", + "/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Returns the number of values ", + "in the set. O(1).\\n */\\n function length(" + ], + [ + "if (nextTokenId != _currentIndex", + ") {\\n // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.\\n " + ], + [ + "_EXP", + "ONENT" + ], + [ + "to` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address to, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _transfer(owner, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``from``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom", + "(\\n address from,\\n address to,\\n uint256 amount\\n " + ], + [ + "\\\",\\n ", + "Strings." + ], + [ + "s to a ", + "point where copy" + ], + [ + "function\\n * ", + "uncallable if the " + ], + [ + "\\n _revert(", + "returndata, errorMessage" + ], + [ + "anal", + "ys" + ], + [ + "LiquidityPair", + "Tokens" + ], + [ + "state-changing ", + "function may " + ], + [ + "Take", + "Fee" + ], + [ + ", from, ", + "_msgSenderERC721A())" + ], + [ + "imag", + "es are " + ], + [ + "_transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function ", + "safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) public virtual override {\\n " + ], + [ + "summ", + "ed ASCII `string` " + ], + [ + "gas to ", + "fit in a block" + ], + [ + "ed\\n * to ", + "mostly " + ], + [ + "https://eips.ethereum.org/EIPS/eip-712#", + "definition" + ], + [ + "be used by ", + "view accessor" + ], + [ + "approx", + "im" + ], + [ + "expensive", + ". This is design" + ], + [ + "masking", + ".\\n assembly {\\n " + ], + [ + "(approvedAddress", + ", from, _msgSenderERC721A())" + ], + [ + ",\\n bytes32[] memory ", + "leaves" + ], + [ + "total number of tokens in existence", + ".\\n * Burned tokens will reduce the count" + ], + [ + "format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{", + "40}) is missing role (0x[0-9a-f]{64})$/" + ], + [ + "memory, which can be ", + "quite " + ], + [ + "It is possible to ", + "prevent this from " + ], + [ + "render the ", + "function\\n * uncallable if the " + ], + [ + "iteral", + "Content\"" + ], + [ + "_packedOwnerships[nextTokenId] == 0) {\\n // If the next slot is within bounds.\\n ", + "if (nextTokenId != _currentIndex) {\\n // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.\\n " + ], + [ + " == 0) {\\n uint256 nextTokenId = tokenId + 1;\\n // If the next slot's address is zero and not burned (i.e. packed value is zero).\\n if (", + "_packedOwnerships[nextTokenId] == 0) {\\n // If the next slot is within bounds.\\n if (nextTokenId != _currentIndex) {\\n // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.\\n " + ], + [ + "ih", + "ood " + ], + [ + "nextInitializedFlag(quantity", + ") | _nextExtraData(address(0), to, " + ], + [ + "This is equivalent to `delete _tokenApprovals[tokenId]", + "`.\\n sstore(approvedAddressSlot, 0" + ], + [ + "` with assembly to avoid redundant ", + "masking.\\n assembly {\\n " + ], + [ + "Developers ", + "should keep in mind " + ], + [ + "call to nonReentrant", + ", _" + ], + [ + "likel", + "ihood " + ], + [ + ", which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // ", + "constructor execution.\\n\\n uint256 size" + ], + [ + "\"useL", + "iteralContent\"" + ], + [ + "unbounded ", + "cost, and using it as part of a " + ], + [ + "of data ", + "(0, since no data" + ], + [ + "es too much ", + "gas to fit in a block" + ], + [ + " of 20 bytes ", + "to its not check" + ], + [ + "true`.\\n _", + "packedOwnerships[tokenId" + ], + [ + "(uint256 approvedAddressSlot, address approvedAddress", + ") = _" + ], + [ + "this; // ", + "silence state mutability warning without generating " + ], + [ + "Calling a ", + "`nonReentrant` function from another " + ], + [ + "\\n // currently is to use assembly", + ".\\n " + ], + [ + ") {\\n bytes32 r", + ";\\n " + ], + [ + "private` function that ", + "does the actual " + ], + [ + "On the first ", + "call to nonReentrant, _" + ], + [ + "set in an ", + "array\\n *\\n * WARNING: This " + ], + [ + "set grow", + "s to a point where copy" + ], + [ + "is not supported. ", + "It is possible to prevent this from " + ], + [ + "gas fees. ", + "Developers should keep in mind " + ], + [ + "https://eips.ethereum.org/EIPS/eip-22", + "00" + ], + [ + "operation will copy the ", + "entire storage to " + ], + [ + "after this point ", + "will fail" + ], + [ + "calling itself, ", + "directly or indirectly" + ], + [ + "ing to memory consum", + "es too much gas to fit in a block" + ], + [ + "By storing the ", + "original value once " + ], + [ + "again, a ", + "refund is trigge" + ], + [ + "Return the entire ", + "set in an array\\n *\\n * WARNING: This " + ], + [ + ";\\n // ecrecover takes the signature parameters, and the only way to get them", + "\\n // currently is to use assembly.\\n " + ], + [ + "that\\n * this function has an ", + "unbounded cost, and using it as part of a " + ], + [ + "Prevents a contract from ", + "calling itself, directly or indirectly" + ], + [ + "Equivalent to `safeTransferFrom(from, to, tokenId, ''", + ")" + ], + [ + ");\\n\\n // Clear approvals from the previous owner.\\n assembly {\\n ", + "if approvedAddress " + ], + [ + "by making the `nonReentrant` function ", + "external, and " + ], + [ + "`address` with fixed length", + " of 20 bytes to its not check" + ], + [ + "s that are queried without any ", + "gas fees. Developers should keep in mind " + ], + [ + "Any calls to nonReentrant ", + "after this point will fail" + ], + [ + "bytecode - see https://github.com/ethereum/solidity/issues/", + "2691" + ], + [ + "state-changing function may ", + "render the function\\n * uncallable if the " + ], + [ + "summed ASCII `string` ", + "hexadecim" + ], + [ + "ed\\n * to mostly ", + "be used by view accessor" + ], + [ + "https://eips.ethereum.org/EIPS/eip-712#definition", + "-of-" + ], + [ + "expensive. This is design", + "ed\\n * to mostly be used by view accessor" + ], + [ + "memory, which can be quite ", + "expensive. This is designed\\n * to mostly be used by view accessor" + ], + [ + "This is equivalent to `delete _tokenApprovals[tokenId]`.\\n sstore(approvedAddressSlot, 0", + ")\\n }\\n }\\n\\n // Underflow of the sender's balance is impossible because we check for\\n // ownership above and the recipient's balance can't realistically overflow.\\n // Counter overflow is incredibly unrealistic as " + ], + [ + "of data (0, since no data", + ")." + ], + [ + "this; // silence state mutability warning without generating ", + "bytecode - see https://github.com/ethereum/solidity/issues/2691" + ], + [ + "Calling a `nonReentrant` function from another ", + "`nonReentrant`" + ], + [ + "private` function that does the actual ", + "work" + ], + [ + "set grows to a point where copy", + "ing to memory consumes too much gas to fit in a block" + ], + [ + "is not supported. It is possible to prevent this from ", + "happen" + ], + [ + "operation will copy the entire storage to ", + "memory, which can be quite expensive. This is designed\\n * to mostly be used by view accessor" + ], + [ + "By storing the original value once ", + "again, a refund is trigge" + ], + [ + "Return the entire set in an array\\n *\\n * WARNING: This ", + "operation will copy the entire storage to memory, which can be quite expensive. This is designed\\n * to mostly be used by view accessor" + ], + [ + "that\\n * this function has an unbounded cost, and using it as part of a ", + "state-changing function may render the function\\n * uncallable if the " + ], + [ + "`address` with fixed length of 20 bytes to its not check", + "summed ASCII `string` hexadecim" + ], + [ + "s that are queried without any gas fees. Developers should keep in mind ", + "that\\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\\n * uncallable if the " + ], + [ + "By storing the original value once again, a refund is trigge", + "red (see" + ], + [ + "Return the entire set in an array\\n *\\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\\n * to mostly be used by view accessor", + "s that are queried without any gas fees. Developers should keep in mind that\\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\\n * uncallable if the " + ], + [ + "Return the entire set in an array\\n *\\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\\n * uncallable if the ", + "set grows to a point where copying to memory consumes too much gas to fit in a block" + ], + [ + "1", + "in" + ], + [ + "8", + "6" + ], + [ + "?", + " _" + ], + [ + "A", + "Min,\\n uint amount" + ], + [ + "F", + "ra" + ], + [ + "M", + "k" + ], + [ + "[", + "token" + ], + [ + "[", + "ERC2309" + ], + [ + "_", + "adapter" + ], + [ + "c", + "ri" + ], + [ + "e", + "5" + ], + [ + "t", + "1" + ], + [ + "}", + ".\\n *\\n * Requirements:\\n *\\n * - " + ], + [ + "▀", + "▀" + ], + [ + "nt", + "h" + ], + [ + "int", + "ial" + ], + [ + "de", + "bt" + ], + [ + "the ", + "address " + ], + [ + "amount", + "s " + ], + [ + "to ", + "keep " + ], + [ + "owner", + "()" + ], + [ + "00", + "1" + ], + [ + ": ", + "https://" + ], + [ + "ip", + "ant" + ], + [ + "transfer", + "percent" + ], + [ + "if", + "old" + ], + [ + "if", + "(_" + ], + [ + "sh", + "utdown" + ], + [ + "es ", + "on the " + ], + [ + "total", + "Asset" + ], + [ + "li", + "ed" + ], + [ + "be", + "acon" + ], + [ + "contract ", + "implements the " + ], + [ + "max", + "Batch" + ], + [ + "burn", + "er" + ], + [ + "can ", + "easily " + ], + [ + " ", + " " + ], + [ + "\\n ", + "@member " + ], + [ + "uint ", + "public " + ], + [ + "com", + "/" + ], + [ + "\"// SPDX-License-Identifier: MIT", + "\\n\\npragma solidity ^0.7.0" + ], + [ + "transferFrom", + "(from, to, tokenId" + ], + [ + "`tokenId` ", + "would have to be 2**256" + ], + [ + "pair", + "For" + ], + [ + "subtr", + "ac" + ], + [ + ")\\\"", + "))" + ], + [ + "_burn", + "(_msgSender(), amount" + ], + [ + "allowed", + "SeaDrop" + ], + [ + "approve ", + "caller is not owner nor " + ], + [ + "approval", + " " + ], + [ + "Us", + "ed" + ], + [ + "owner ", + ":= and" + ], + [ + "delegat", + "es[" + ], + [ + "then ", + "add" + ], + [ + "modifier ", + "onlyOwner(" + ], + [ + "string memory) {\\n return ", + "_symbol" + ], + [ + "string memory) {\\n return ", + "_name" + ], + [ + "up ", + "a " + ], + [ + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev ", + "Standard " + ], + [ + ",\\n uint amount", + "AMin,\\n uint amount" + ], + [ + "UN", + "CTION" + ], + [ + "keccak256(", + "bytes" + ], + [ + ", r", + ", vs" + ], + [ + "net", + "Sy" + ], + [ + "ized ", + "ownership slot" + ], + [ + "da", + "ve/" + ], + [ + ".\\r", + "\\n */\\r\\n" + ], + [ + "Emits an {Approval", + "} event indicating the updated allowance" + ], + [ + "uint96 ", + "feeNumerator" + ], + [ + "[account", + "] = " + ], + [ + ".sol';\\nimport '", + "./" + ], + [ + "packedOwnerships[", + "startTokenId" + ], + [ + "`.\\n _", + "packedOwnerships[startTokenId" + ], + [ + ");\\n }\\n\\n ", + "/**\\n * @notice " + ], + [ + "math/Math", + ".sol\"" + ], + [ + "](", + "https://eips.ethereum.org/EIPS/eip-2" + ], + [ + " {\\n using ", + "SafeMath for uint256" + ], + [ + "╠╠", + "╠╠" + ], + [ + "_callOptionalReturn", + "(token, abi.encodeWithSelector(token." + ], + [ + "mid", + "d" + ], + [ + "uint112 ", + "reserve1" + ], + [ + "_h", + "drn" + ], + [ + "Le", + "ft" + ], + [ + "log_", + "2" + ], + [ + "Upgradeability", + "Proxy" + ], + [ + "address(uniswapV2Router", + "), " + ], + [ + ".\\n * To ", + "get the total number of tokens minted, please " + ], + [ + "Mask `", + "owner" + ], + [ + "0x00000000000000000000000000000000", + "0000dEaD" + ], + [ + "OpenZeppelin Contracts guidelines: functions revert\\n * instead returning `false` on failure. This behavior is nonetheless\\n * conventional and does not conflict with the expectations of ERC20\\n * applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping(address => uint256) private _balances;\\n\\n mapping(address => mapping(address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The default value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5.05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `", + "to` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address to, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _transfer(owner, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``from``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 amount\\n " + ], + [ + "tokensInto", + "Liquidity" + ], + [ + "Internal function to invoke {IERC721Receiver-onERC721Received} on a target ", + "address" + ], + [ + "\\\\xe3\\\\x82", + "\\\\x8" + ], + [ + "math utilities missing in the Solidity language.\\n */\\nlibrary ", + "Math" + ], + [ + "&& to ", + "!= " + ], + [ + "_dollar_value", + "_d18" + ], + [ + "String operations.\\n */\\nlibrary Strings {\\n bytes16 private constant _HEX_SYMBOLS = \\\"0123456789abcdef\\\"", + ";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = _HEX_SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n}\\n\"" + ], + [ + "an un", + "intial" + ], + [ + "total number of tokens in existence.\\n * Burned tokens will reduce the count", + ".\\n * To get the total number of tokens minted, please " + ], + [ + "[ERC2309", + "](https://eips.ethereum.org/EIPS/eip-2" + ], + [ + "approve caller is not owner nor ", + "approved for all" + ], + [ + ",\\n uint amountAMin,\\n uint amount", + "B" + ], + [ + "an unintial", + "ized ownership slot" + ], + [ + "[ERC2309](https://eips.ethereum.org/EIPS/eip-2", + "309" + ], + [ + "(", + ");\\r\\n " + ], + [ + ")", + ");" + ], + [ + ",", + "\\r\\n " + ], + [ + ".", + "toUint" + ], + [ + "4", + "/" + ], + [ + "D", + "oc" + ], + [ + "F", + "EE" + ], + [ + "I", + "c" + ], + [ + "N", + "ow" + ], + [ + "_", + "uniswapV2Pair" + ], + [ + "_", + "NOT_ENTERED" + ], + [ + "l", + "t" + ], + [ + "{", + "value: " + ], + [ + "s ", + "& " + ], + [ + "int", + "16" + ], + [ + ", ", + "delegatee" + ], + [ + "tr", + "on" + ], + [ + "token", + "s (" + ], + [ + "is", + "CodeHash" + ], + [ + "ER", + "S" + ], + [ + "le", + "ft " + ], + [ + "in ", + "{" + ], + [ + ";\\n ", + "string " + ], + [ + "ta", + "in" + ], + [ + "on ", + "every " + ], + [ + "atu", + "res" + ], + [ + "tokens ", + "to be " + ], + [ + "this ", + "point" + ], + [ + "for", + "k" + ], + [ + "\\n // ", + "https://eips.ethereum.org/EIPS/eip-2200" + ], + [ + "iz", + "e the " + ], + [ + "buy", + "percent" + ], + [ + "(_", + "totalSupply" + ], + [ + "pos", + "si" + ], + [ + "sell", + "percent" + ], + [ + "0, ", + "uint amount1" + ], + [ + "col", + "or" + ], + [ + ".\\n * ", + "Calling a `nonReentrant` function from another `nonReentrant`" + ], + [ + "balance ", + "query for " + ], + [ + "in the ", + "same " + ], + [ + " <", + "= _" + ], + [ + "call ", + "a\\n * `" + ], + [ + "RO", + "Y" + ], + [ + "░░", + "░" + ], + [ + " {\\n ", + "struct " + ], + [ + "denominator", + " == " + ], + [ + "pool", + "Info" + ], + [ + "tra", + "vers" + ], + [ + "down", + "scale" + ], + [ + "Deleg", + "ates " + ], + [ + ",\\n * ", + "and " + ], + [ + "De", + "prec" + ], + [ + "()", + ")." + ], + [ + "project", + "s" + ], + [ + "ing\\n * ", + "by making the `nonReentrant` function external, and " + ], + [ + "subscri", + "ber" + ], + [ + "712", + "]" + ], + [ + "includ", + "ing " + ], + [ + "\"contracts/", + "interfaces/" + ], + [ + "_D", + "URATION" + ], + [ + "/// @", + "inheritdoc " + ], + [ + "OU", + "T" + ], + [ + "leaf", + "` " + ], + [ + ") == ", + "from" + ], + [ + "pause", + "Window" + ], + [ + " - 1", + ") / b" + ], + [ + ").\\n *\\n * Counterpart to Solidity's `", + "uint" + ], + [ + ".\\n */\\n modifier ", + "nonReentrant(" + ], + [ + "\\n * function ", + "is not supported. It is possible to prevent this from happen" + ], + [ + "s. ", + "To " + ], + [ + "Exit", + "Pool" + ], + [ + "hel", + "ps " + ], + [ + "srcRep", + "Old" + ], + [ + "ing the\\n * ", + "zero " + ], + [ + "contains(", + "set, value" + ], + [ + "filtered", + "CodeHash" + ], + [ + "Ent", + "e" + ], + [ + "[EIP ", + "712]" + ], + [ + " bits\\\");\\n return ", + "uint" + ], + [ + ".\\n * ", + "Only " + ], + [ + "_lock", + "('" + ], + [ + "](", + "https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified" + ], + [ + "[EIP section", + "](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified" + ], + [ + ") {\\n require(value <= type(", + "uint" + ], + [ + "increase", + "s " + ], + [ + ", so we ", + "round " + ], + [ + "Set storage set, bytes32 value", + ") private returns (bool) {\\n " + ], + [ + "Element", + "s are " + ], + [ + "safeTransferFrom(from, to, tokenId", + ", \\\"\\\"" + ], + [ + " from uint256, reverting on\\n * overflow (when the input is greater than largest ", + "uint" + ], + [ + "er's ", + "Delight" + ], + [ + "Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {", + "safeTransferFrom}\\n * " + ], + [ + ").interfaceId ||\\n ", + "interfaceId == type(IERC721Metadata" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (", + "access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _transferOwnership(_msgSender());\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev " + ], + [ + "tree ", + "up" + ], + [ + "try ", + "IERC721Receiver(to).onERC721Received(_msgSender(), " + ], + [ + "_status = _", + "ENTERED" + ], + [ + "rebuil", + "t " + ], + [ + "tre", + "e. " + ], + [ + ") internal pure ", + "virtual returns (" + ], + [ + "pre-", + "images are " + ], + [ + "unchecked {\\n return ", + "_currentIndex - " + ], + [ + "e-", + "2.0" + ], + [ + "set._inner, bytes32(value", + "));\\n }\\n\\n /**\\n * @dev " + ], + [ + "If `to` refers to a smart contract, it must implement\\n * {", + "IERC721Receiver-onERC721Received}, which is called upon a safe transfer" + ], + [ + "0.7.", + "6" + ], + [ + "{\\n // ", + "This is equivalent to `delete _tokenApprovals[tokenId]`.\\n sstore(approvedAddressSlot, 0)\\n }\\n }\\n\\n // Underflow of the sender's balance is impossible because we check for\\n // ownership above and the recipient's balance can't realistically overflow.\\n // Counter overflow is incredibly unrealistic as " + ], + [ + "acti", + "vat" + ], + [ + "signing ", + "domain" + ], + [ + "assumed to be ", + "sorted" + ], + [ + "(_IMPLEMENTATION_SLOT", + ")." + ], + [ + "Apach", + "e-2.0" + ], + [ + ").interfaceId ||\\n super.supportsInterface(interfaceId", + ");\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner" + ], + [ + "root of the ", + "tree. " + ], + [ + " is Context, ERC165", + ", IERC721" + ], + [ + "+= quantity`.\\n // - `numberMinted += quantity`.\\n //\\n // We can directly add to the ", + "`balance` and `numberMinted" + ], + [ + "\\\"Hack", + "er's Delight" + ], + [ + "Filte", + "red" + ], + [ + ")\\n );\\n\\n // ", + "If the next slot may not have been initialized (i.e. `nextInitialized == false`) .\\n if (prevOwnershipPacked " + ], + [ + " == 0) {\\n uint256 nextTokenId = tokenId + 1;\\n // If the next slot's address is zero and not burned (i.e. packed value is zero).\\n if (_packedOwnerships[nextTokenId] == 0) {\\n // If the next slot is within bounds.\\n if (nextTokenId != _currentIndex) {\\n // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.\\n ", + "_packedOwnerships[nextTokenId] = prevOwnershipPacked;\\n }\\n }\\n }\\n }\\n\\n emit Transfer" + ], + [ + "Prevents a contract from calling itself, directly or indirectly", + ".\\n * Calling a `nonReentrant` function from another `nonReentrant`" + ], + [ + "Equivalent to `safeTransferFrom(from, to, tokenId, '')", + "`.\\n */\\n function " + ], + [ + ");\\n\\n // Clear approvals from the previous owner.\\n assembly {\\n if approvedAddress ", + "{\\n // This is equivalent to `delete _tokenApprovals[tokenId]`.\\n sstore(approvedAddressSlot, 0)\\n }\\n }\\n\\n // Underflow of the sender's balance is impossible because we check for\\n // ownership above and the recipient's balance can't realistically overflow.\\n // Counter overflow is incredibly unrealistic as " + ], + [ + "private` function that does the actual work", + ".\\n */\\n modifier nonReentrant(" + ], + [ + "By storing the original value once again, a refund is triggered (see", + "\\n // https://eips.ethereum.org/EIPS/eip-2200" + ], + [ + "Ic", + "sa" + ], + [ + "call a\\n * `", + "private` function that does the actual work.\\n */\\n modifier nonReentrant(" + ], + [ + "\\n * function is not supported. It is possible to prevent this from happen", + "ing\\n * by making the `nonReentrant` function external, and " + ], + [ + "pre-images are ", + "assumed to be sorted" + ], + [ + "Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`", + "\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and " + ], + [ + " ", + "OR " + ], + [ + "*", + "\\n * " + ], + [ + "1", + " << " + ], + [ + "9", + "c" + ], + [ + "d", + "aily" + ], + [ + "j", + "s." + ], + [ + "n", + "ested" + ], + [ + "{", + "\\n * " + ], + [ + "\\n", + " " + ], + [ + "s ", + "an address " + ], + [ + "en", + "se " + ], + [ + "int", + "32" + ], + [ + ", ", + "scalingFactor" + ], + [ + "un", + "it" + ], + [ + "function", + ".\\n *\\n * " + ], + [ + "ow", + "er " + ], + [ + ");", + "\\n * " + ], + [ + ": ", + "the " + ], + [ + ": ", + "amount exceeds " + ], + [ + "an ", + "the " + ], + [ + "contract", + "Balance " + ], + [ + "pri", + "or " + ], + [ + "by ", + "subtrac" + ], + [ + "par", + "tition" + ], + [ + "the zero address", + "\\\");\\r\\n require(" + ], + [ + "error", + "Code" + ], + [ + "current", + "Amp" + ], + [ + " _", + "__" + ], + [ + "this ", + "one" + ], + [ + "bytes32 ", + "internal " + ], + [ + "Int", + "er" + ], + [ + ") internal pure returns (", + "uint256) {\\r\\n " + ], + [ + "in the ", + "contract" + ], + [ + "payable", + "(" + ], + [ + "En", + "d " + ], + [ + "Not", + "e " + ], + [ + "me", + "ant" + ], + [ + ",\\n address to,\\n uint256 ", + "deadline" + ], + [ + "update", + "SellFees" + ], + [ + "out", + "put " + ], + [ + ".\\n *\\n * ", + "This " + ], + [ + ".\\n ", + "_totalSupply -= " + ], + [ + ".\\n ", + "error " + ], + [ + ".\\n ", + "*\\n * " + ], + [ + "To ", + "prevent " + ], + [ + "s\\n * ", + "zero.\\n */\\n function average" + ], + [ + "_set", + "TokenRoyalty" + ], + [ + "first ", + "read " + ], + [ + "price", + "Average" + ], + [ + "caller is not ", + "token " + ], + [ + "}\\r\\n", + " " + ], + [ + "string memory) {\\n return ", + "toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH" + ], + [ + "initializ", + "e " + ], + [ + "s `amount` tokens from ", + "the caller" + ], + [ + "_Available since v4.", + "5._" + ], + [ + "statu", + "s = _" + ], + [ + "TokenId ", + "= _" + ], + [ + "_P", + "RO" + ], + [ + "ven", + "ance " + ], + [ + "track", + " of " + ], + [ + "_statu", + "s != " + ], + [ + "), \\\"ERC721: ", + "transfer to non ERC721Receiver implementer" + ], + [ + "`)", + ".\\n */\\n function _" + ], + [ + "replac", + "e the " + ], + [ + ",\\n bytes memory _data\\n ", + ") internal virtual {\\n _mint" + ], + [ + "shl", + "(_" + ], + [ + "ERC20-", + "allowance" + ], + [ + "por", + "tion" + ], + [ + "Initial", + "izer" + ], + [ + "token/ERC721/IERC721", + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../" + ], + [ + "\\\";\\n ", + "uint8 private constant _ADDRESS_LENGTH = 20" + ], + [ + "uint256(_", + "at(set._inner, index" + ], + [ + "early", + "Buy" + ], + [ + "big", + "g" + ], + [ + "rid", + "ge" + ], + [ + "constructor() ", + "ERC20(\\\"" + ], + [ + "proxy/", + "utils/" + ], + [ + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b", + ") / 2 can overflow" + ], + [ + "######", + "#(" + ], + [ + "_msgSender() == ", + "owner || " + ], + [ + "retr", + "ieve " + ], + [ + ";\\n\\n // Mapping from token ID to approved address", + "\\n mapping(uint256 => address) private " + ], + [ + "`.\\n ", + "uint256 private constant _" + ], + [ + "0 ? string(abi.encodePacked(baseURI, ", + "tokenId.toString())" + ], + [ + "` to the lower 160 bits, in case the upper bits somehow aren't clean.\\n ", + "owner := and" + ], + [ + ".\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, `from`'s ", + "`tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, `tokenId` will be burned by `from`.\\n * - `from` and `to` are never both zero.\\n */\\n function _" + ], + [ + "rounds ", + "up " + ], + [ + "Request ", + "memory " + ], + [ + "Immut", + "able" + ], + [ + "index out of bounds", + "\\\");\\n return " + ], + [ + "path[", + "1] = " + ], + [ + "SeaDrop(", + "seaDropImpl" + ], + [ + "(\\n address from,\\n address to,\\n uint256 amount\\n ) external returns (bool", + ");\\n}\\n\"" + ], + [ + "feeRate", + "." + ], + [ + "approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount", + ") public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20" + ], + [ + "put in ", + "plac" + ], + [ + "decrementing then ", + "incrementing" + ], + [ + "two numbers. The result is rounded toward", + "s\\n * zero.\\n */\\n function average" + ], + [ + "(address addr) internal pure returns (", + "string memory) {\\n return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH" + ], + [ + "BITPOS_NUMBER_MINTED) | 1);\\n\\n // Updates:\\n // - `address` to the owner.\\n // - `startTimestamp` to the timestamp of minting.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `quantity == 1", + "`.\\n _packedOwnerships[startTokenId" + ], + [ + "ownership.burned ", + "== false" + ], + [ + "Mask `owner", + "` to the lower 160 bits, in case the upper bits somehow aren't clean.\\n owner := and" + ], + [ + "_status != ", + "_ENTERED" + ], + [ + "0 ? string(abi.encodePacked(baseURI, tokenId.toString())", + ") : " + ], + [ + "two numbers. The result is rounded towards\\n * zero.\\n */\\n function average", + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow" + ], + [ + "\"", + "l" + ], + [ + "(", + "a " + ], + [ + "(", + "bool _" + ], + [ + ")", + ". We " + ], + [ + "1", + " and " + ], + [ + "3", + "C" + ], + [ + "6", + " " + ], + [ + "K", + "ind " + ], + [ + "R", + "ang" + ], + [ + "S", + "\\n // =============================================================" + ], + [ + "_", + "call" + ], + [ + "`", + ".\\n *\\n * Requirements:\\n *\\n * - `" + ], + [ + "b", + "ank" + ], + [ + "d", + "uc" + ], + [ + "g", + "aug" + ], + [ + "s", + ",\\n " + ], + [ + "\\n", + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + ], + [ + "\\n ", + "_status = _ENTERED" + ], + [ + "ad", + "v" + ], + [ + "in", + "valid" + ], + [ + "in", + "clusive" + ], + [ + "un", + "lik" + ], + [ + "ed ", + "the " + ], + [ + "amount", + " is " + ], + [ + "` ", + "- the first " + ], + [ + "from", + "TokenId" + ], + [ + "acc", + "u" + ], + [ + "el", + "se {" + ], + [ + "es ", + "a " + ], + [ + "(address ", + "_address" + ], + [ + "(uint256 ", + "tokenAmount" + ], + [ + "token ", + "owner" + ], + [ + "e {", + "\\n " + ], + [ + "\\n // ", + "decrementing then incrementing" + ], + [ + "Requirements:", + "\\n *\\n * " + ], + [ + "\\n ", + "}\\n\\n " + ], + [ + "content", + "s " + ], + [ + "s[", + "msg.sender" + ], + [ + "] = ", + "_balances[recipient" + ], + [ + "Un", + "lock" + ], + [ + "))", + ")\\n " + ], + [ + "Pro", + "ject " + ], + [ + ".\\n * ", + "This " + ], + [ + "path", + "[0] = " + ], + [ + "point", + "s to " + ], + [ + "fee", + "s are " + ], + [ + "lat", + "est " + ], + [ + ")\\n ", + "_status = _NOT_ENTERED" + ], + [ + "_S", + "END" + ], + [ + ",\\n ", + "'" + ], + [ + " ", + "/**\\n * " + ], + [ + "}.", + "\\n */\\n function " + ], + [ + "ech", + "/" + ], + [ + ")\\\", p0, p1", + "));\\n\\t}\\n\\n\\tfunction " + ], + [ + "update", + "BuyFees" + ], + [ + "Deleg", + "at" + ], + [ + ".\\n ", + "_balances[account] += amount" + ], + [ + ".\\n ", + " " + ], + [ + "startTokenId", + "` - the first " + ], + [ + "owner ", + "query for nonexistent token" + ], + [ + "packed ", + ">> _" + ], + [ + "PER", + "IO" + ], + [ + "ix", + "el" + ], + [ + ") public view returns (", + "bool" + ], + [ + "because ", + "there is " + ], + [ + "fy", + "Token" + ], + [ + "position", + " of the " + ], + [ + "encod", + "ing\\n * " + ], + [ + ".sol\\\";\\nimport \\\"../../", + "utils/Address" + ], + [ + "largest ", + "of two numbers.\\n */\\n function " + ], + [ + "UN", + "SAFE_" + ], + [ + "see {", + "_totalMinted" + ], + [ + "small", + "er " + ], + [ + "_allTokens", + "Index[tokenId" + ], + [ + ")\\n public", + "\\n " + ], + [ + "AG", + "PL-3.0" + ], + [ + "Second", + "s.add(" + ], + [ + "TOKEN", + " C" + ], + [ + "unchecked {\\n // ", + "Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above" + ], + [ + ".\\n *\\n * NOTE: ", + "This " + ], + [ + "totalSupply ", + "= " + ], + [ + "DA", + "O" + ], + [ + "s from ", + "standard " + ], + [ + ")\\\", p0, p1, p2));\\n\\t}\\n\\n\\tfunction ", + "log(address " + ], + [ + "market", + "places " + ], + [ + "more expensi", + "ve" + ], + [ + ")\\n external\\n ", + "onlyOwner" + ], + [ + "enfor", + "ce " + ], + [ + "& _BITMASK", + "_NEXT_INITIALIZED" + ], + [ + "merkle ", + "tre" + ], + [ + "Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * ", + "[EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified" + ], + [ + "al representation.\\n */\\n function toHexString", + "(address addr) internal pure returns (string memory) {\\n return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH" + ], + [ + "`\\n * - `", + "extraData = " + ], + [ + "toMask", + "ed " + ], + [ + "toMask", + "ed, " + ], + [ + "buyback", + "FeeReceiver" + ], + [ + ")\\\", p0, p1, p2));\\n\\t}\\n\\n\\tfunction log(", + "bool " + ], + [ + ")\\\", p0, p1, p2));\\n\\t}\\n\\n\\tfunction log(", + "string memory " + ], + [ + "burnFrom", + "(address account, uint256 amount" + ], + [ + "capp", + "ed to a " + ], + [ + "histor", + "y " + ], + [ + ") { ", + "return " + ], + [ + "Emit ", + "the `Transfer` " + ], + [ + "<< _", + "BITPOS_EXTRA_DATA" + ], + [ + "a set of serially-ordered ", + "token ID" + ], + [ + ";\\n uint256 private constant _", + "ENTERED = 2" + ], + [ + "TokenApproval", + "Ref " + ], + [ + "address(0) && ", + "ownership.burned == false" + ], + [ + "allowed SeaDrop", + " contract" + ], + [ + "@notice", + " " + ], + [ + "Under", + "lying" + ], + [ + ".\\n unchecked {\\n // Updates:\\n // - `balance ", + "+= quantity`.\\n // - `numberMinted += quantity`.\\n //\\n // We can directly add to the `balance` and `numberMinted" + ], + [ + "`quantity` ", + "- the amount to be transferred" + ], + [ + "] = _packOwnershipData(\\n to,\\n _", + "nextInitializedFlag(quantity) | _nextExtraData(address(0), to, " + ], + [ + "(i.e. `", + "ownership.addr" + ], + [ + "getApprovedSlotAndAddress", + "(tokenId" + ], + [ + "attribu", + "t" + ], + [ + "_approve(address(this), ", + "address(uniswapV2Router), " + ], + [ + "UniswapV3", + "Pool" + ], + [ + "ther", + "wis" + ], + [ + "restric", + "ted " + ], + [ + ")\\\", p0, p1, p2));\\n\\t\\tignored;\\n\\t}\\n\\n\\tfunction ", + "log(" + ], + [ + "lastManual", + "LpBurnTime" + ], + [ + "b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest ", + "of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a " + ], + [ + "StorageSlot.getAddressSlot", + "(_IMPLEMENTATION_SLOT)." + ], + [ + " D", + "ATA " + ], + [ + "AMM", + "Pair" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Converts an ", + "`address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecim" + ], + [ + "the sum of all balances is capped by totalSupply, and the sum is preserved by", + "\\n // decrementing then incrementing" + ], + [ + "N_CO", + "INS" + ], + [ + "NOT_ENTERED = 1", + ";\\n uint256 private constant _ENTERED = 2" + ], + [ + "(\\n address owner,\\n address spender,\\n uint256 amount\\n ) internal virtual {\\n uint256 currentAllowance = allowance(owner, spender);\\n if (currentAllowance != type(uint256).max) {\\n require(currentAllowance >= amount, \\\"ERC20: insufficient allowance\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - amount);\\n }\\n }\\n }\\n\\n /**\\n * @dev ", + "Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {}\\n\\n /**\\n * @dev Hook that is called after any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * has been transferred to `to`.\\n * - when `from` is zero, `amount` tokens have been minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {}\\n}\\n\"" + ], + [ + "recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-", + "approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20" + ], + [ + "isApprovedForAll(from, _msgSenderERC721A())", + ") revert TransferCallerNotOwnerNorApproved" + ], + [ + "Any calls to nonReentrant after this point will fail", + "\\n _status = _ENTERED" + ], + [ + "By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200", + ")\\n _status = _NOT_ENTERED" + ], + [ + ".\\n _totalSupply -= ", + "amount;\\n }\\n\\n emit Transfer" + ], + [ + ";\\n\\n // Mapping from token ID to approved address\\n mapping(uint256 => address) private ", + "_tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping(address => mapping(address => bool)) private _operatorApprovals" + ], + [ + ".\\n _balances[account] += amount", + ";\\n }\\n " + ], + [ + "startTokenId` - the first ", + "token ID" + ], + [ + "PERIO", + "D" + ], + [ + "largest of two numbers.\\n */\\n function ", + "max(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a " + ], + [ + "Seconds.add(", + "days" + ], + [ + "TOKEN C", + "OUNT" + ], + [ + "unchecked {\\n // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above", + ".\\n _balances[account] += amount;\\n }\\n " + ], + [ + "Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified", + ")\\n * " + ], + [ + "Emit the `Transfer` ", + "event" + ], + [ + "address(0) && ownership.burned == false", + "`)" + ], + [ + "] = _packOwnershipData(\\n to,\\n _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, ", + "0)\\n " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecim", + "al representation.\\n */\\n function toHexString(address addr) internal pure returns (string memory) {\\n return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH" + ], + [ + "the sum of all balances is capped by totalSupply, and the sum is preserved by\\n // decrementing then incrementing", + ".\\n " + ], + [ + "!", + "_exists(tokenId), \\\"ERC721: " + ], + [ + "\"", + "X" + ], + [ + "\"", + "0\"" + ], + [ + "(", + "uint256" + ], + [ + ".", + "pop(" + ], + [ + "/", + "256 bits" + ], + [ + "C", + "VX" + ], + [ + "F", + "rozen" + ], + [ + "I", + "st" + ], + [ + "T", + "ier" + ], + [ + "_", + "out" + ], + [ + "_", + "extraData" + ], + [ + "`", + "token" + ], + [ + "a", + "6" + ], + [ + "n", + "ative" + ], + [ + "res", + "c" + ], + [ + "ro", + "y " + ], + [ + "amount", + ". Since " + ], + [ + "ma", + "tron" + ], + [ + "account", + "s with " + ], + [ + "transfer", + "s" + ], + [ + "ERC20", + "Capped" + ], + [ + "return ", + "the current " + ], + [ + "bu", + "f" + ], + [ + "di", + "ver" + ], + [ + "pro", + "vider" + ], + [ + "bytes32", + "[] memory" + ], + [ + "value ", + "of a " + ], + [ + "value ", + "makes " + ], + [ + "that ", + "does not " + ], + [ + "low", + " in " + ], + [ + "the", + "\\n * " + ], + [ + "0x", + "4" + ], + [ + "0x", + "a" + ], + [ + "0x", + "d" + ], + [ + " * ", + "x" + ], + [ + "/// ", + "@param _" + ], + [ + "of the ", + "full " + ], + [ + "s[", + "role]." + ], + [ + "com", + "ing into " + ], + [ + "; ", + "// S" + ], + [ + "e the ", + "refund " + ], + [ + "fi", + "le" + ], + [ + "will be ", + "lower " + ], + [ + "OpenZeppelin Contract", + "s v4." + ], + [ + "OpenZeppelin Contract", + "s (last updated v4." + ], + [ + "exceed", + "s the " + ], + [ + "Reward", + "Pool" + ], + [ + "Res", + "tr" + ], + [ + "after", + "-" + ], + [ + "block.timestamp", + " <= " + ], + [ + "s are ", + "capped to a " + ], + [ + ";\\n }\\n\\n /**\\n * @dev See {", + "IERC721Enumerable-" + ], + [ + "burned", + "." + ], + [ + "EX", + "P" + ], + [ + "Enumerable", + "Map" + ], + [ + ";\\r\\n ", + "}\\r\\n }\\r\\n" + ], + [ + "\\n *", + "\\n * @param _" + ], + [ + "they ", + "have " + ], + [ + "token ID", + "s owned by " + ], + [ + "_buy", + "back" + ], + [ + "- `", + "index` must be strictly less than {length" + ], + [ + "gas", + ", it is " + ], + [ + "result += ", + "1" + ], + [ + "like ", + "this one" + ], + [ + "Sh", + "if" + ], + [ + ") >> ", + "1" + ], + [ + "amount exceeds allowance", + "\\\")" + ], + [ + "Ext", + "ernal " + ], + [ + "Share", + "s " + ], + [ + "how ", + "much " + ], + [ + "them ", + "low in " + ], + [ + "Join", + "Pool" + ], + [ + "exempt", + "Fee" + ], + [ + "() external view returns (address", + ");\\n\\n function " + ], + [ + "MerkleProof", + "." + ], + [ + "ile", + ": " + ], + [ + "non-zero ", + "value makes " + ], + [ + "{\\n using ", + "Address for address;\\n using Strings for uint256" + ], + [ + "NFT ", + "Royalty " + ], + [ + " a ", + "bit " + ], + [ + "to != ", + "owner" + ], + [ + "_addressData", + "[to]." + ], + [ + "smart ", + "contract " + ], + [ + "exchang", + "e the refund " + ], + [ + "refund", + "s are capped to a " + ], + [ + "ffffffffffffffffffffffffffffffff", + "ffffffffffffffffffffffff" + ], + [ + "blog", + ".openzeppelin.com/" + ], + [ + "disabled", + "." + ], + [ + " \\u003c", + " " + ], + [ + "deployment", + " a bit " + ], + [ + ";\\n // Overflow not possible: ", + "the sum of all balances is capped by totalSupply, and the sum is preserved by\\n // decrementing then incrementing.\\n " + ], + [ + "Alloc", + "ation" + ], + [ + " of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `", + "+" + ], + [ + "(\\n IERC20 token", + ",\\n address spender,\\n uint256 value\\n ) internal {\\n " + ], + [ + "revert(add(32, reason), mload(reason", + "))" + ], + [ + "_startTokenId()", + "`." + ], + [ + "`spender", + "` is allowed to " + ], + [ + "roleMember", + "s[role]." + ], + [ + "checkpoints[account", + "][" + ], + [ + "copi", + "es " + ], + [ + "increase the ", + "likelihood " + ], + [ + "address[] memory path", + " = new address[](" + ], + [ + "divide ", + "by " + ], + [ + "best ", + "to keep " + ], + [ + ",\\n uint amountAMin,\\n uint amountB", + "Min,\\n address to,\\n uint deadline" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _transferOwnership(_msgSender());\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev ", + "Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\"" + ], + [ + ");\\n\\n // Clear approvals from the previous owner.\\n assembly {\\n if approvedAddress {\\n // This is equivalent to `delete _tokenApprovals[tokenId]`.\\n sstore(approvedAddressSlot, 0)\\n }\\n }\\n\\n // Underflow of the sender's balance is impossible because we check for\\n // ownership above and the recipient's balance can't realistically overflow.\\n // Counter overflow is incredibly unrealistic as ", + "`tokenId` would have to be 2**256" + ], + [ + ".\\n *\\n * ", + "Requirements:\\n *\\n * " + ], + [ + "accu", + "rac" + ], + [ + " /**\\n * ", + "@dev Returns the " + ], + [ + "merkle tre", + "es " + ], + [ + "!_exists(tokenId), \\\"ERC721: ", + "token already minted" + ], + [ + "Ist", + "anbul" + ], + [ + "amount. Since ", + "refunds are capped to a " + ], + [ + "of the full ", + "refund " + ], + [ + "- `index` must be strictly less than {length", + "}.\\n */\\n function " + ], + [ + "gas, it is ", + "best to keep " + ], + [ + "non-zero value makes ", + "deployment a bit " + ], + [ + "NFT Royalty ", + "Standard" + ], + [ + "exchange the refund ", + "on every " + ], + [ + ";\\n // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\\n // decrementing then incrementing.\\n ", + "_balances[to] += " + ], + [ + "increase the likelihood ", + "of the full refund " + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * ", + "- `index` must be strictly less than {length}.\\n */\\n function " + ], + [ + "gas, it is best to keep ", + "them low in " + ], + [ + " ", + "function " + ], + [ + "#", + "@" + ], + [ + "/", + "` in " + ], + [ + "3", + "0." + ], + [ + "S", + "old" + ], + [ + "W", + "H" + ], + [ + "_", + "sellMarketingFee" + ], + [ + "`", + "private" + ], + [ + "p", + "enalty" + ], + [ + "p", + "ending " + ], + [ + "s", + ".s" + ], + [ + "{", + "nonReentrant" + ], + [ + "\\n", + "*/" + ], + [ + "to", + "TokenId" + ], + [ + "res", + "ol" + ], + [ + ", ", + "functions marked " + ], + [ + ") ", + "calls to " + ], + [ + "ing", + ", and it " + ], + [ + "ed ", + "around " + ], + [ + "a ", + "!= " + ], + [ + "` ", + "`nonReentrant` " + ], + [ + "su", + "ch" + ], + [ + "ERC20", + ".sol\\\";\\nimport \\\"../../../" + ], + [ + "external", + "` `nonReentrant` " + ], + [ + ") internal ", + "override " + ], + [ + "and ", + "alternative " + ], + [ + " to ", + "first read " + ], + [ + "require(", + "\\r\\n " + ], + [ + ") external ", + "{\\n return super._" + ], + [ + "if (", + "to.isContract()" + ], + [ + "be", + "half" + ], + [ + "contract ", + "upgrades " + ], + [ + "token ", + "== " + ], + [ + "this", + ", " + ], + [ + ";\\n\\n", + "/*" + ], + [ + "on ", + "addition" + ], + [ + ").", + "div" + ], + [ + ") {\\n ", + "return" + ], + [ + "content", + "s, " + ], + [ + "cannot be ", + "disabled." + ], + [ + "MM", + "M" + ], + [ + "On", + "Sell" + ], + [ + "than ", + "uint256 or " + ], + [ + "def", + "ense " + ], + [ + "out ", + "our " + ], + [ + "Lo", + "ad" + ], + [ + "any ", + "type that " + ], + [ + "call ", + "one " + ], + [ + "s are ", + "more expensive " + ], + [ + ";\\n\\n // ", + "=============================================================\\n // " + ], + [ + "back", + ". This is the " + ], + [ + "tokensFor", + "Burn" + ], + [ + ";\\n\\n ", + "_" + ], + [ + "functions ", + "`private" + ], + [ + "call to ", + "nonReentrant " + ], + [ + "ond", + "on\"" + ], + [ + "Counterpart to ", + "Solidity\\u0027s `" + ], + [ + "operation ", + "emits an " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Returns the ", + "unpacked `TokenOwnership` struct " + ], + [ + "Gu", + "arant" + ], + [ + "each ", + "write " + ], + [ + "Note that ", + "because there is " + ], + [ + "up ", + "by the " + ], + [ + "division ", + "with `" + ], + [ + ", which ", + "can be applied to " + ], + [ + "stak", + "ing " + ], + [ + "being ", + "non-zero value makes deployment a bit " + ], + [ + ".sol\\\";\\n\\n", + "abstract contract " + ], + [ + "because ", + "each write " + ], + [ + "drop", + "Stage" + ], + [ + "ReentrancyGuard", + "` will " + ], + [ + "work", + "ed around " + ], + [ + "check ", + "out our " + ], + [ + "values ", + "being non-zero value makes deployment a bit " + ], + [ + "produc", + "ing " + ], + [ + "rele", + "as" + ], + [ + "calcul", + "ated " + ], + [ + "available", + ", which can be applied to " + ], + [ + "\\n * @param _", + "data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function " + ], + [ + "\\n // =============================================================\\n\\n /**\\n * @dev ", + "Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)\\n * " + ], + [ + ") external view returns (bool", + ");\\n\\n // =============================================================\\n // " + ], + [ + "prevent ", + "reentrant " + ], + [ + "overflow ", + "on addition" + ], + [ + ");\\n }\\n\\n ", + "if (" + ], + [ + "a single ", + "`nonReentrant` " + ], + [ + "divis", + "or" + ], + [ + "paramet", + "ers " + ], + [ + "mean", + "s that " + ], + [ + "bits ", + "taken " + ], + [ + "() public ", + "view override returns (" + ], + [ + "Author", + "iz" + ], + [ + "tokenIndex", + "] = " + ], + [ + "ing `", + "external` `nonReentrant` " + ], + [ + "`nonReentrant` ", + "may not " + ], + [ + "functions to ", + "make sure " + ], + [ + ") {\\n ", + "return " + ], + [ + "against ", + "contract upgrades " + ], + [ + "OPERATIONS\\n // =============================================================\\n\\n /**\\n * @dev ", + "Returns the " + ], + [ + "`, and ", + "then add" + ], + [ + "from `", + "ReentrancyGuard` will " + ], + [ + "reentrancy ", + "and alternative " + ], + [ + "to learn more about ", + "reentrancy and alternative " + ], + [ + "voting pow", + "er" + ], + [ + "TIP: ", + "If you " + ], + [ + "word ", + "because each write " + ], + [ + "PRO", + "OF" + ], + [ + "/[", + "Reentrancy " + ], + [ + "ceil", + "ing of the " + ], + [ + "those ", + "functions `private" + ], + [ + "to learn more about how these ids are created.\\n *\\n * This function call must use less than 3", + "0000 " + ], + [ + "there are no ", + "nested" + ], + [ + "pointer ", + "alias" + ], + [ + ".\\n *\\n * `", + "startTokenId` - the first token ID" + ], + [ + "it's ", + "recommended to use it alway" + ], + [ + " OPERATIONS\\n // =============================================================\\n\\n /**\\n * @dev ", + "Returns the " + ], + [ + "make the ", + "{nonReentrant" + ], + [ + "Level", + "Call" + ], + [ + "` in packed ", + "ownership.\\n uint256 private constant _" + ], + [ + "protect against ", + "it, " + ], + [ + "Basic", + "Token" + ], + [ + "Boolean", + "s are more expensive " + ], + [ + "artist", + "Address" + ], + [ + "blog", + " post" + ], + [ + "(address to, uint256 quantity", + ") internal virtual {\\n uint256 " + ], + [ + "another", + ". This can be " + ], + [ + ") internal pure returns (address, RecoverError", + ") {\\n // " + ], + [ + "cases ", + "like this one" + ], + [ + "Time = ", + "block.timestamp" + ], + [ + "1, ", + "2, " + ], + [ + "}\\n }\\n\\n // =============================================================\\n // ", + " " + ], + [ + "After ", + "Istanbul" + ], + [ + "// F", + "ile: " + ], + [ + ", and then ", + "write" + ], + [ + "SenderApprovedOrOwner", + "(approvedAddress, from, _msgSenderERC721A())" + ], + [ + "Contract module that ", + "helps " + ], + [ + " of the `nextInitialized` ", + "bit in packed ownership.\\n uint256 private constant _" + ], + [ + "takes ", + "up a " + ], + [ + "}.\\n *\\n * Requirements:\\n *\\n * - `", + "sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom" + ], + [ + "IDex", + "Router" + ], + [ + ") {\\n assembly {\\n // ", + "Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.\\n owner := and" + ], + [ + "guard", + ", functions marked " + ], + [ + "a ^ b", + ") / 2" + ], + [ + " to be transferred.\\n * ", + "`quantity` - the amount to be transferred" + ], + [ + "istanbul", + "/[Reentrancy " + ], + [ + "if (!_is", + "SenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A())" + ], + [ + "c >= a", + ", \\\"SafeMath: addition overflow" + ], + [ + "percentage of the ", + "total" + ], + [ + "reentrancy-", + "after-" + ], + [ + "}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be ", + "`account`.\\n */\\n function " + ], + [ + " can ", + "overflow on addition" + ], + [ + "from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred", + "\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function " + ], + [ + "a & b) + (", + "a ^ b) / 2" + ], + [ + "reentrant", + ") calls to " + ], + [ + "proportional", + " to the " + ], + [ + "Top", + "LevelCall" + ], + [ + "[to] += quantity * (", + "(1 << _" + ], + [ + "class of bugs, so ", + "it's recommended to use it alway" + ], + [ + "differ", + "s from standard " + ], + [ + " IERC721Metadata", + "\\n // =============================================================\\n\\n /**\\n * @dev Returns the " + ], + [ + " IERC165", + "\\n // =============================================================\\n\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)\\n * " + ], + [ + "boolean", + ", and then write" + ], + [ + "extra SLOAD", + " to first read " + ], + [ + "but in ", + "exchange the refund on every " + ], + [ + "would like ", + "to learn more about reentrancy and alternative " + ], + [ + "Inheriting ", + "from `ReentrancyGuard` will " + ], + [ + "(uint256 approvedAddressSlot, address approvedAddress) = _", + "getApprovedSlotAndAddress(tokenId" + ], + [ + "total number of tokens in existence.\\n * Burned tokens will reduce the count.\\n * To get the total number of tokens minted, please ", + "see {_totalMinted" + ], + [ + " - 1) / b", + " can overflow on addition" + ], + [ + "If `to` refers to a smart contract, it must implement\\n * {IERC721Receiver-onERC721Received}, which is called upon a safe transfer", + ".\\n *\\n * Emits a {Transfer} event.\\n */\\n function " + ], + [ + "replace the ", + "bits taken " + ], + [ + "`.\\n uint256 private constant _", + "BITMASK" + ], + [ + "\"l", + "ondon\"" + ], + [ + "Seconds.add(days", + "30." + ], + [ + "coming into ", + "effect" + ], + [ + "blog.openzeppelin.com/", + "reentrancy-after-" + ], + [ + "amount. Since refunds are capped to a ", + "percentage of the total" + ], + [ + ";\\n // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\\n // decrementing then incrementing.\\n _balances[to] += ", + "amount;\\n }\\n\\n emit Transfer" + ], + [ + "increase the likelihood of the full refund ", + "coming into effect" + ], + [ + "gas, it is best to keep them low in ", + "cases like this one" + ], + [ + "/` in ", + "that it " + ], + [ + "ing, and it ", + "cannot be disabled." + ], + [ + "contents, ", + "replace the bits taken " + ], + [ + "than uint256 or ", + "any type that " + ], + [ + "defense ", + "against contract upgrades " + ], + [ + "call one ", + "another. This can be " + ], + [ + "call to nonReentrant ", + "will be lower " + ], + [ + "operation emits an ", + "extra SLOAD to first read " + ], + [ + "Note that because there is ", + "a single `nonReentrant` " + ], + [ + "up by the ", + "boolean, and then write" + ], + [ + "division with `", + "/` in that it " + ], + [ + "worked around ", + "by mak" + ], + [ + "check out our ", + "blog post" + ], + [ + "values being non-zero value makes deployment a bit ", + "more expensive" + ], + [ + "available, which can be applied to ", + "functions to make sure " + ], + [ + "prevent reentrant ", + "calls to a " + ], + [ + "ing `external` `nonReentrant` ", + "entry" + ], + [ + "`nonReentrant` may not ", + "call one another. This can be " + ], + [ + "`, and then add", + "ing `external` `nonReentrant` entry" + ], + [ + "TIP: If you ", + "would like to learn more about reentrancy and alternative " + ], + [ + "word because each write ", + "operation emits an extra SLOAD to first read " + ], + [ + "ceiling of the ", + "division of " + ], + [ + "those functions `private", + "`, and then adding `external` `nonReentrant` entry" + ], + [ + "pointer alias", + "ing, and it cannot be disabled." + ], + [ + ".\\n *\\n * `startTokenId` - the first token ID", + " to be transferred.\\n * `quantity` - the amount to be transferred" + ], + [ + "make the {nonReentrant", + "} " + ], + [ + "protect against it, ", + "check out our blog post" + ], + [ + "Booleans are more expensive ", + "than uint256 or any type that " + ], + [ + "After Istanbul", + "]." + ], + [ + "Contract module that helps ", + "prevent reentrant calls to a " + ], + [ + "takes up a ", + "full" + ], + [ + "istanbul/[Reentrancy ", + "After Istanbul]." + ], + [ + "differs from standard ", + "division with `/` in that it " + ], + [ + " IERC165\\n // =============================================================\\n\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)\\n * ", + "to learn more about how these ids are created.\\n *\\n * This function call must use less than 30000 " + ], + [ + "but in exchange the refund on every ", + "call to nonReentrant will be lower " + ], + [ + "Inheriting from `ReentrancyGuard` will ", + "make the {nonReentrant} " + ], + [ + " - 1) / b can overflow on addition", + ", so we distribute" + ], + [ + "blog.openzeppelin.com/reentrancy-after-", + "istanbul/[Reentrancy After Istanbul]." + ], + [ + "gas, it is best to keep them low in cases like this one", + ", to" + ], + [ + "contents, replace the bits taken ", + "up by the boolean, and then write" + ], + [ + "Note that because there is a single `nonReentrant` ", + "guard, functions marked " + ], + [ + "available, which can be applied to functions to make sure ", + "there are no nested" + ], + [ + "`nonReentrant` may not call one another. This can be ", + "worked around by mak" + ], + [ + "TIP: If you would like to learn more about reentrancy and alternative ", + "ways" + ], + [ + "Booleans are more expensive than uint256 or any type that ", + "takes up a full" + ], + [ + "(", + "when the " + ], + [ + ",", + "\\n /// " + ], + [ + ",", + "\\n * " + ], + [ + "6", + "00" + ], + [ + ";", + "\\n *\\n * " + ], + [ + "A", + "lp" + ], + [ + "D", + "R" + ], + [ + "[", + "recipient" + ], + [ + "d", + "g" + ], + [ + "s", + "d" + ], + [ + "═", + "╝" + ], + [ + "tu", + "r" + ], + [ + ", ", + "address(0)" + ], + [ + "return", + "ed" + ], + [ + "\\n * ", + "to " + ], + [ + "at", + "es the " + ], + [ + "is", + "sion" + ], + [ + "address ", + "- " + ], + [ + "` ", + "hook" + ], + [ + "/**", + "\\n * @title " + ], + [ + "@dev", + " " + ], + [ + "\\n *", + " " + ], + [ + "ERC20", + ".sol\"" + ], + [ + "ul", + "k" + ], + [ + "value", + "\\n ) internal {\\n " + ], + [ + "\\n * ", + "points to " + ], + [ + "not ", + "paused" + ], + [ + "/ ", + "/ " + ], + [ + "Ex", + "ec" + ], + [ + "num", + "erator" + ], + [ + "on ", + "its " + ], + [ + ", \\\"", + "ReentrancyGuard: reentrant call" + ], + [ + "0x", + "c" + ], + [ + ";\\n }\\n\\n /**\\n * @dev ", + "Returns true if the " + ], + [ + ";\\n }\\n\\n /**\\n * @dev ", + "Sets the " + ], + [ + ";\\n }\\n\\n /**\\n * @dev ", + "Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and " + ], + [ + "mul", + "(x, y" + ], + [ + ") external view returns (", + "address pair" + ], + [ + "\\n // ", + "transaction" + ], + [ + "\\n // ", + "back. This is the " + ], + [ + "\\n // ", + "increase the likelihood of the full refund coming into effect" + ], + [ + "\\n // ", + "word because each write operation emits an extra SLOAD to first read " + ], + [ + "Hash", + ", " + ], + [ + ") external", + ";\\n}\\n\\n" + ], + [ + "keccak256", + "(0x" + ], + [ + "pool", + "-utils/" + ], + [ + "(address indexed ", + "sender" + ], + [ + "reward", + "PerToken" + ], + [ + ";\\n }\\n ", + "_totalSupply -= amount;\\n\\n emit Transfer" + ], + [ + "owner ", + "address" + ], + [ + "amountETH", + "Liquidity" + ], + [ + " := ", + "or(" + ], + [ + "call to ", + "`to" + ], + [ + "approved ", + "address " + ], + [ + "22", + "3" + ], + [ + "\\\"\\n ", + ");\\n require(\\n " + ], + [ + "upgrade", + "able " + ], + [ + "Fin", + "anc" + ], + [ + "overrid", + "en " + ], + [ + "\\n\\t * ", + "@param " + ], + [ + ".\\n uint256 private constant _", + "NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2" + ], + [ + "mean", + "s the " + ], + [ + "s in ", + "a " + ], + [ + "restriction", + "s on " + ], + [ + "deduc", + "ting " + ], + [ + "dest", + "roy " + ], + [ + "\\n * https://", + "blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]." + ], + [ + ";\\n\\n uint256 private ", + "_status" + ], + [ + ") external;\\n\\n /**\\n * @notice ", + "Update " + ], + [ + "modifier\\n * ", + "available, which can be applied to functions to make sure there are no nested" + ], + [ + "#(", + "#(" + ], + [ + "\\n * to ", + "protect against it, check out our blog post" + ], + [ + "ing\\n * ", + "those functions `private`, and then adding `external` `nonReentrant` entry" + ], + [ + ";\\r\\n }\\r\\n\\r\\n /**\\r\\n * @dev ", + "See {IERC20-" + ], + [ + "Initial", + "ize" + ], + [ + "{\\n // ", + "Booleans are more expensive than uint256 or any type that takes up a full" + ], + [ + "))\\n ", + "}\\n }\\n\\n /**\\n * @dev Returns the " + ], + [ + "_balances[recipient", + "] = _balances[recipient" + ], + [ + ");\\n }\\n", + "}\"" + ], + [ + "_RE", + "CE" + ], + [ + "\\n * ", + "bytes4(keccak256('" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (", + "token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom" + ], + [ + "====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize", + ", which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size" + ], + [ + "free memory ", + "pointer " + ], + [ + "\\n * (", + "reentrant) calls to " + ], + [ + ";\\n // Overflow not possible: ", + "amount <= accountBalance <= totalSupply" + ], + [ + "together ", + "with {" + ], + [ + "them.\\n *\\n * ", + "Note that because there is a single `nonReentrant` guard, functions marked " + ], + [ + "them.\\n *\\n * ", + "TIP: If you would like to learn more about reentrancy and alternative ways" + ], + [ + "updateSwap", + "TokensAtAmount" + ], + [ + "==========", + " */" + ], + [ + "\\n\\n // The ", + "values being non-zero value makes deployment a bit more expensive" + ], + [ + "(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage", + ");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes" + ], + [ + ",\\n // ", + "but in exchange the refund on every call to nonReentrant will be lower " + ], + [ + "& _BITMASK_ADDRESS_DATA_ENTRY;\\n }\\n\\n /**\\n * Returns the ", + "number of tokens " + ], + [ + "Dep", + "loy" + ], + [ + ") returns (bool) {\\n ", + "return\\n interfaceId == type(IERC721" + ], + [ + "Propos", + "al" + ], + [ + ";\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ", + "====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0" + ], + [ + "Address.sol)\\n\\npragma solidity ^0.8.1", + ";\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0" + ], + [ + "Extension of ", + "{ERC20" + ], + [ + "as\\n * ", + "`nonReentrant` may not call one another. This can be worked around by mak" + ], + [ + "< b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of ", + "two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow" + ], + [ + "affili", + "ate" + ], + [ + "in\\n // ", + "amount. Since refunds are capped to a percentage of the total" + ], + [ + "s with added overflow", + "\\n * " + ], + [ + "flo", + "or" + ], + [ + "EnumerableSet for ", + "EnumerableSet.AddressSet" + ], + [ + ".swapExact", + "TokensFor" + ], + [ + "and\\n // ", + "pointer aliasing, and it cannot be disabled." + ], + [ + "Moves ", + "tokens " + ], + [ + "function.\\n *\\n * ", + "Inheriting from `ReentrancyGuard` will make the {nonReentrant} " + ], + [ + "token/ERC721/IERC721.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../", + "utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to" + ], + [ + "rounds up ", + "instead" + ], + [ + "b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a ", + "< b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow" + ], + [ + "accurac", + "y" + ], + [ + "!_exists(tokenId), \\\"ERC721: token already minted", + "\\\");\\n\\n " + ], + [ + "}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function ", + "renounceRole(bytes32 role, address account" + ], + [ + "defense against contract upgrades ", + "and\\n // pointer aliasing, and it cannot be disabled." + ], + [ + "Contract module that helps prevent reentrant calls to a ", + "function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} " + ], + [ + "differs from standard division with `/` in that it ", + "rounds up instead" + ], + [ + "gas, it is best to keep them low in cases like this one, to", + "\\n // increase the likelihood of the full refund coming into effect" + ], + [ + "contents, replace the bits taken up by the boolean, and then write", + "\\n // back. This is the " + ], + [ + "\\n * points to ", + "them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways" + ], + [ + "\\n // word because each write operation emits an extra SLOAD to first read ", + "the\\n // " + ], + [ + ".\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2", + ";\\n\\n uint256 private _status" + ], + [ + "modifier\\n * available, which can be applied to functions to make sure there are no nested", + "\\n * (reentrant) calls to " + ], + [ + "\\n * to protect against it, check out our blog post", + "\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]." + ], + [ + "ing\\n * those functions `private`, and then adding `external` `nonReentrant` entry", + "\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways" + ], + [ + "{\\n // Booleans are more expensive than uint256 or any type that takes up a full", + "\\n // word because each write operation emits an extra SLOAD to first read the\\n // " + ], + [ + "them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked ", + "as\\n * `nonReentrant` may not call one another. This can be worked around by mak" + ], + [ + "\\n\\n // The values being non-zero value makes deployment a bit more expensive", + ",\\n // but in exchange the refund on every call to nonReentrant will be lower " + ], + [ + "in\\n // amount. Since refunds are capped to a percentage of the total", + "\\n // transaction" + ], + [ + "defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.", + "\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower " + ], + [ + "Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} ", + "modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to " + ], + [ + "gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect", + ".\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status" + ], + [ + "ing\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways", + "\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]." + ], + [ + "them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by mak", + "ing\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]." + ], + [ + "defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower ", + "in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction" + ], + [ + "Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to ", + "them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]." + ], + [ + " ", + "signature " + ], + [ + "\"", + "Invalid " + ], + [ + "\"", + "ERC777" + ], + [ + "(", + "https://github.com/" + ], + [ + "(", + "fees * " + ], + [ + ".", + "\\n * @param _" + ], + [ + "/", + "lib/" + ], + [ + "J", + "EC" + ], + [ + "P", + "Y" + ], + [ + "W", + "rit" + ], + [ + "]", + ";\\n\\n emit Transfer" + ], + [ + "_", + "allowance" + ], + [ + "_", + "BITMASK_ADDRESS" + ], + [ + "_", + "exists(" + ], + [ + "`", + "a" + ], + [ + "`", + "uint256" + ], + [ + "f", + "ound" + ], + [ + "y", + "e" + ], + [ + "res", + "h" + ], + [ + "end", + "ed" + ], + [ + "is ", + "true, the " + ], + [ + "ing ", + "an " + ], + [ + ": ", + "it " + ], + [ + "value", + ";\\n }\\n\\n /**\\n * @dev " + ], + [ + "tokenId", + "s.length" + ], + [ + "(address ", + "new" + ], + [ + "index", + " = " + ], + [ + "at ", + "this " + ], + [ + "\\r\\n", + "\\r\\n function " + ], + [ + "mint", + "ed by " + ], + [ + "that ", + "was " + ], + [ + "token ", + "collection" + ], + [ + "check", + "s.\\n *\\n * " + ], + [ + ");\\n\\n ", + "return " + ], + [ + "sign", + "ed" + ], + [ + "can", + "Mint" + ], + [ + "when ", + "filtered " + ], + [ + "Contract", + "Address" + ], + [ + "\"// SPDX-License-Identifier: ", + "AGPL-3.0" + ], + [ + "\\r\\n * ", + "@param " + ], + [ + "Pro", + "venanceHash" + ], + [ + "new ", + "implementation" + ], + [ + "fee", + "Growth" + ], + [ + "eip", + "1967" + ], + [ + "`tokenId` ", + "is " + ], + [ + "pair", + ", bool " + ], + [ + "grad", + "ually " + ], + [ + "_to", + "String" + ], + [ + ");\\n }\\n\\n function ", + "get" + ], + [ + "has ", + "be" + ], + [ + "Mo", + "re " + ], + [ + "safeTransferFrom", + "(address from, address to, uint256 tokenId" + ], + [ + "uint256 private ", + "constant " + ], + [ + "s for ", + "self" + ], + [ + ") internal view virtual returns (", + "TokenOwnership memory) {\\n return _unpackedOwnership" + ], + [ + " > 0", + ", \\\"" + ], + [ + "mechanism", + "s to " + ], + [ + "factory", + "() external pure returns (address" + ], + [ + "tokenId ", + ":= add(" + ], + [ + "e.g", + ".\\n * " + ], + [ + "ed = ", + "true" + ], + [ + "s.\\n *\\n * ", + "Using this library instead of the unchecked operations eliminates an entire" + ], + [ + "_ ", + "The " + ], + [ + "_safeMint", + "(to, tokenId" + ], + [ + "reason", + ".length" + ], + [ + "(x", + " * " + ], + [ + "` operator.\\n *\\n * Requirements:\\n *\\n * - ", + "Addition cannot overflow.\\n */\\n function add" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n", + "pragma solidity 0.8." + ], + [ + ");\\n }\\n\\n /**\\n * @dev See {", + "IERC20Permit-" + ], + [ + "kn", + "own" + ], + [ + "Gener", + "al" + ], + [ + "INITIAL", + "_SUPPLY" + ], + [ + "(address spender, uint256 ", + "tokenId" + ], + [ + "sa", + "ving" + ], + [ + "swap ", + "fee " + ], + [ + "),", + "\\n " + ], + [ + "invariant", + " " + ], + [ + ":\\n *", + " " + ], + [ + "(owner", + ", _BITMASK_ADDRESS)\\n // " + ], + [ + "cach", + "ed" + ], + [ + ";\\n emit Approval", + "(" + ], + [ + "Trac", + "k" + ], + [ + ", 0x20", + ")\\n // " + ], + [ + "Comp", + "li" + ], + [ + "Comp", + "ound" + ], + [ + "::::::::", + "::::::::" + ], + [ + "registered ", + "address - " + ], + [ + "CR", + "V" + ], + [ + "s[i", + "] = " + ], + [ + "isApprovedForAll(owner, ", + "spender" + ], + [ + "kk", + "kk" + ], + [ + "exchang", + "e." + ], + [ + "a given ", + "address or its subscription" + ], + [ + "Ab", + "str" + ], + [ + "sload", + "(" + ], + [ + "Air", + "drop" + ], + [ + "Map storage ", + "map" + ], + [ + "Maximum", + " " + ], + [ + "(from, to, amount);\\n\\n _afterTokenTransfer(from, to, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n ", + "unchecked {\\n // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\\n _balances[account] += amount;\\n }\\n " + ], + [ + ".\\n mstore(", + "str" + ], + [ + "onlyAllowedOperator(from", + ") {\\n " + ], + [ + "oppos", + "ed to " + ], + [ + "(gas", + "(), " + ], + [ + ") returns (bool", + ") {\\n return interfaceId == type(" + ], + [ + "operation overflow", + "s.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire" + ], + [ + "\\n }\\n packed = (", + "packed & _BITMASK" + ], + [ + "analys", + "is" + ], + [ + "1in", + "ch" + ], + [ + ")\\n );\\n\\n // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .\\n if (prevOwnershipPacked ", + "& _BITMASK_NEXT_INITIALIZED" + ], + [ + ": amount exceeds ", + "96" + ], + [ + "status = _", + "NOT_ENTERED" + ], + [ + ".\\n unchecked {\\n // Updates:\\n // - `balance += quantity`.\\n // - `numberMinted += quantity`.\\n //\\n // We can directly add to the `balance` and `numberMinted", + "`.\\n _packedAddressData" + ], + [ + ";\\n // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\\n // decrementing then incrementing.\\n _balances[to] += amount;\\n }\\n\\n emit Transfer", + "(from, to, amount);\\n\\n _afterTokenTransfer(from, to, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n unchecked {\\n // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\\n _balances[account] += amount;\\n }\\n " + ], + [ + ";\\n // Overflow not possible: amount <= accountBalance <= totalSupply", + ".\\n _totalSupply -= amount;\\n }\\n\\n emit Transfer" + ], + [ + "s with added overflow\\n * ", + "checks.\\n *\\n * " + ], + [ + "Moves tokens ", + "`amount` " + ], + [ + "when filtered ", + "is true, the " + ], + [ + "eip1967", + ".proxy." + ], + [ + "registered address - ", + "when filtered is true, the " + ], + [ + "a given address or its subscription", + ".\\n */\\n function " + ], + [ + "operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire", + "\\n * " + ], + [ + "5", + "3" + ], + [ + "A", + "ri" + ], + [ + "I", + "E" + ], + [ + "P", + "or" + ], + [ + "S", + "o" + ], + [ + "T", + "YP" + ], + [ + "W", + "L" + ], + [ + "_", + "shares" + ], + [ + "`", + "\\n *\\n * " + ], + [ + "c", + " < " + ], + [ + "m", + "ix" + ], + [ + "n", + "ative " + ], + [ + "s", + "ite" + ], + [ + "v", + "g" + ], + [ + "\\n ", + ");\\n event " + ], + [ + "er", + "." + ], + [ + ", ", + "J" + ], + [ + "ing", + "Enabled" + ], + [ + ");", + "\\n // " + ], + [ + "token", + "1 " + ], + [ + "\\n ", + "//" + ], + [ + "= ", + "0" + ], + [ + "\\n\\n ", + "/// @notice " + ], + [ + "su", + "r" + ], + [ + "index", + "es" + ], + [ + "\\n }\\n\\n /**\\n * @dev ", + "Returns the " + ], + [ + "from ", + "`sender` to `recipient" + ], + [ + "TH", + "OR" + ], + [ + "The ", + "token " + ], + [ + "The ", + "number of tokens " + ], + [ + "on ", + "SeaDrop" + ], + [ + "TokenId", + "s" + ], + [ + ")\\n ", + "}\\n " + ], + [ + "_S", + "IZ" + ], + [ + "ffff", + "fff" + ], + [ + "&&", + "\\r\\n " + ], + [ + "}\\n ", + "if (" + ], + [ + "(address indexed ", + "user" + ], + [ + ");\\r\\n ", + "}\\r\\n\\r\\n " + ], + [ + "1 ", + "word " + ], + [ + "WETH", + "() external pure returns (address" + ], + [ + ".\\n ", + "uint256 " + ], + [ + "s = ", + "new " + ], + [ + "on the ", + "set. O(1" + ], + [ + "scal", + "ing " + ], + [ + "static ", + "call failed\"" + ], + [ + ", 1", + ")\\n } " + ], + [ + "Mapping ", + "from " + ], + [ + "while (", + "true" + ], + [ + "_allTokens", + "[" + ], + [ + "] = true", + ";\\r\\n " + ], + [ + "(sender, recipient, amount", + ");\\n " + ], + [ + "App", + "lication" + ], + [ + "Valid", + "ator" + ], + [ + "assert", + "(" + ], + [ + "\\n require(", + "_status != _ENTERED" + ], + [ + "approve(address to, uint256 tokenId", + ") internal virtual {\\n " + ], + [ + "\"Address: low-level ", + "static call failed\"" + ], + [ + "aver", + "age " + ], + [ + "relat", + "ed to " + ], + [ + "[account", + "]" + ], + [ + "consi", + "dered " + ], + [ + "Subtr", + "act " + ], + [ + "nft ", + "contract " + ], + [ + "range", + ", " + ], + [ + "Sp", + "ec" + ], + [ + "Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20", + " {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom" + ], + [ + "incredibly unrealis", + "tic" + ], + [ + "insufficient allowance", + "\"" + ], + [ + "\\\");\\n\\n // ", + "Any calls to nonReentrant after this point will fail\\n _status = _ENTERED" + ], + [ + "explicitOwnership", + "Of" + ], + [ + "swit", + "ch" + ], + [ + "\\r\\n /**\\r\\n * ", + "@dev Returns the " + ], + [ + "Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event", + ".\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function " + ], + [ + "emit Transfer(address(0), account, amount);\\n\\n _afterTokenTransfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n unchecked {\\n _balances[account] = accountBalance - amount", + ";\\n // Overflow not possible: amount <= accountBalance <= totalSupply.\\n _totalSupply -= amount;\\n }\\n\\n emit Transfer" + ], + [ + "exact", + "ly " + ], + [ + "ReentrancyGuard ", + "{\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // " + ], + [ + "IDEX", + "Router" + ], + [ + "power", + "s of " + ], + [ + "getApproved(tokenId) == ", + "spender" + ], + [ + "\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n", + "\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\"" + ], + [ + "(\\n uint256 a,\\n uint256 b", + ",\\n string memory errorMessage\\n " + ], + [ + "██╔", + "══" + ], + [ + "Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event", + ".\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function " + ], + [ + "renounce ", + "role" + ], + [ + "frequencyIn", + "Seconds" + ], + [ + "Dat", + "a storage " + ], + [ + ") internal onlyInitializ", + "ing " + ], + [ + ") == from", + ", \\\"ERC721: " + ], + [ + "token IDs owned by ", + "`owner" + ], + [ + ") {\\n assembly {\\n // Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.\\n owner := and", + "(owner, _BITMASK_ADDRESS)\\n // " + ], + [ + ", \\\"ReentrancyGuard: reentrant call", + "\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom", + "(\\n address from,\\n address to,\\n uint256 amount\\n ) external returns (bool);\\n}\\n\"" + ], + [ + ";\\n // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\\n // decrementing then incrementing.\\n _balances[to] += amount;\\n }\\n\\n emit Transfer(from, to, amount);\\n\\n _afterTokenTransfer(from, to, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n unchecked {\\n // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\\n _balances[account] += amount;\\n }\\n ", + "emit Transfer(address(0), account, amount);\\n\\n _afterTokenTransfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n unchecked {\\n _balances[account] = accountBalance - amount;\\n // Overflow not possible: amount <= accountBalance <= totalSupply.\\n _totalSupply -= amount;\\n }\\n\\n emit Transfer" + ], + [ + "Moves tokens `amount` ", + "from `sender` to `recipient" + ], + [ + "\\n require(_status != _ENTERED", + ", \\\"ReentrancyGuard: reentrant call\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED" + ], + [ + "\"", + "/contracts/" + ], + [ + "(", + "uint16 " + ], + [ + "4", + "7" + ], + [ + "<", + "Timestamp" + ], + [ + "<", + "Address of " + ], + [ + "B", + "8" + ], + [ + "H", + "ead" + ], + [ + "V", + "AR" + ], + [ + "_", + "pid" + ], + [ + "`", + "data` " + ], + [ + "c", + "et" + ], + [ + "g", + "es " + ], + [ + "o", + "ses " + ], + [ + "p", + "df" + ], + [ + "\\n", + "abstract contract " + ], + [ + "\\n ", + "delete " + ], + [ + "th", + "me" + ], + [ + "un", + "claimed" + ], + [ + "es", + "ti" + ], + [ + "is", + "Minter" + ], + [ + "require", + "ment" + ], + [ + "er ", + "for " + ], + [ + "si", + "z" + ], + [ + "tokenId", + ", " + ], + [ + "tokenId", + "To" + ], + [ + "ch", + "unk" + ], + [ + "set", + "s the " + ], + [ + "), ", + "to, tokenId" + ], + [ + "ab", + "s " + ], + [ + "mint", + "ers" + ], + [ + "internal", + "Type" + ], + [ + "This ", + "also " + ], + [ + "current", + "Balance" + ], + [ + ";\\n\\n", + "/// @title " + ], + [ + "name", + "` " + ], + [ + "name", + "` and a `" + ], + [ + "are ", + "the " + ], + [ + "symbol", + "` to the " + ], + [ + ", address ", + "_to" + ], + [ + ", \\\"", + "ERC20Permit" + ], + [ + "of", + "\\n * " + ], + [ + "dead", + "line " + ], + [ + "))", + ");\\n }\\n\\n /**\\n * @dev " + ], + [ + "\"ERC20: ", + "insufficient allowance\"" + ], + [ + "main", + "/src/" + ], + [ + "Pool", + " is " + ], + [ + ") {\\n ", + "revert " + ], + [ + "exceed", + "ed" + ], + [ + " > ", + "a" + ], + [ + "uint amount", + "B" + ], + [ + "e that ", + "the " + ], + [ + "tion ", + "by " + ], + [ + "27", + "e" + ], + [ + "del", + "ay" + ], + [ + "bool,", + "address" + ], + [ + "bool,", + "bool" + ], + [ + "bool,", + "string" + ], + [ + "s for ", + "a " + ], + [ + "no ", + "restrictions on " + ], + [ + "implement ", + "alternative " + ], + [ + "includ", + "ed " + ], + [ + ");\\n require(", + "_checkOnERC721Received" + ], + [ + "} and {", + "ERC20-allowance" + ], + [ + "pow", + "er " + ], + [ + "If the ", + "`tokenId` is " + ], + [ + "custom", + ":" + ], + [ + "Metadata ", + "{\\n using Address for address;\\n using Strings for uint256" + ], + [ + "Internal ", + "Balance " + ], + [ + "a `", + "name` and a `" + ], + [ + "_msgSenderERC721A", + "()" + ], + [ + ", string memory errorMessage", + ") private pure " + ], + [ + "additional ", + "data" + ], + [ + "operator ", + "query for nonexistent token" + ], + [ + ".\\n *\\n * _Available since v4.", + "7._\\n */\\n function " + ], + [ + "a contract.\\n *\\n * ", + "@param " + ], + [ + "_000_000", + "_000" + ], + [ + ",\\n bool ", + "approveMax, uint8 v, bytes32 r, bytes32 s" + ], + [ + ".\\n * The ", + "call is not executed if the target address is not " + ], + [ + "address(this)", + ",\\n " + ], + [ + "(\\n bytes32 ", + "poolId" + ], + [ + "pending", + "Owner" + ], + [ + "Project", + "Id" + ], + [ + "Returns whether ", + "`spender` is allowed to " + ], + [ + "Ou", + "t = " + ], + [ + "Sto", + "red" + ], + [ + "ability ", + "for " + ], + [ + "there is ", + "a " + ], + [ + "xs", + "d" + ], + [ + "AccessControl: ", + "can only " + ], + [ + "token transfer", + ", such as " + ], + [ + "\\\",\\\"", + "name\\\":\\\"" + ], + [ + ", IERC721", + "Metadata {\\n using Address for address;\\n using Strings for uint256" + ], + [ + "_O", + "VERFLOW" + ], + [ + "multiplication", + " of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `" + ], + [ + "integer division", + " of two unsigned integ" + ], + [ + "Remain", + "der " + ], + [ + "(uint16 _", + "srcChainId" + ], + [ + "\\\"],\\n [", + "\\\"" + ], + [ + "address signer = ", + "ecrecover" + ], + [ + "_balances[sender] = ", + "_balances[sender" + ], + [ + "].sub(amount, \\\"ERC20: transfer ", + "amount exceeds allowance\\\")" + ], + [ + "accounts that have ", + "`role" + ], + [ + "facilit", + "ator" + ], + [ + "Off", + "set" + ], + [ + "LOGIC", + "\\n //////////////////////////////////////////////////////////////*/\\n\\n function " + ], + [ + "(uint256 x", + ", uint256 " + ], + [ + "depending ", + "on the " + ], + [ + "addressData", + "[owner]." + ], + [ + "(receiver, ", + "feeNumerator" + ], + [ + "UniswapPair", + "Oracle" + ], + [ + "INonFungible", + "SeaDropToken" + ], + [ + "_balances[account] += amount;\\n ", + "emit Transfer(address(0), account, amount);\\n\\n _afterTokenTransfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n unchecked {\\n _balances[account] = accountBalance - amount" + ], + [ + "As ", + "opposed to " + ], + [ + "Art ", + "Block" + ], + [ + ")));\\r\\n ", + "_lock('" + ], + [ + "messag", + "ing " + ], + [ + "by setting ", + "a `name` and a `" + ], + [ + "(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function ", + "transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) public virtual override {\\n " + ], + [ + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n uint256 c = a + b", + ";\\n require(" + ], + [ + "Returns an array of ", + "token IDs owned by `owner" + ], + [ + "Internal function to invoke {IERC721Receiver-onERC721Received} on a target address", + ".\\n * The call is not executed if the target address is not " + ], + [ + "meant", + " to be " + ], + [ + "proxy/utils/", + "Initializable" + ], + [ + "BITPOS_NUMBER_MINTED) | 1);\\n\\n // Updates:\\n // - `address` to the owner.\\n // - `startTimestamp` to the timestamp of minting.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `quantity == 1`.\\n _packedOwnerships[startTokenId", + "] = _packOwnershipData(\\n to,\\n _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)\\n " + ], + [ + "(address to, uint256 quantity) internal virtual {\\n uint256 ", + "startTokenId = _currentIndex;\\n if (" + ], + [ + "Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].", + "\\n */\\nabstract contract " + ], + [ + "Ari", + "thme" + ], + [ + "c < ", + "a" + ], + [ + "Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function ", + "grantRole(bytes32 role, address account" + ], + [ + "Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function ", + "revokeRole(bytes32 role, address account" + ], + [ + "renounce role", + "s for self" + ], + [ + "oses ", + "no restrictions on " + ], + [ + "internalType", + "\\\":\\\"" + ], + [ + "symbol` to the ", + "token collection" + ], + [ + "implement alternative ", + "mechanisms to " + ], + [ + "Returns whether `spender` is allowed to ", + "manage " + ], + [ + "AccessControl: can only ", + "renounce roles for self" + ], + [ + "token transfer, such as ", + "signature" + ], + [ + "multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `", + "*" + ], + [ + "by setting a `name` and a `", + "symbol` to the token collection" + ], + [ + "Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not ", + "a contract.\\n *\\n * @param " + ], + [ + "oses no restrictions on ", + "msg.sender" + ], + [ + "(", + "via " + ], + [ + ".", + "\\n /// @return " + ], + [ + "C", + "ID" + ], + [ + "S", + "WAP" + ], + [ + "W", + "W" + ], + [ + "[", + "WARNING" + ], + [ + "_", + "c" + ], + [ + "_", + "buildDomainSeparator" + ], + [ + "f", + "5" + ], + [ + "l", + "ayer" + ], + [ + "t", + "able" + ], + [ + "ad", + "r" + ], + [ + "an", + "e" + ], + [ + ", ", + "vestingRound" + ], + [ + "ou", + "ch" + ], + [ + "turn", + " " + ], + [ + "de", + "pos" + ], + [ + "\\n ", + "for {" + ], + [ + "ar", + "ren" + ], + [ + "f ", + ":= " + ], + [ + "\\\"", + ": " + ], + [ + "Token", + ": " + ], + [ + ") {", + "}\\n\\n /**\\n * @dev " + ], + [ + "Tr", + "a" + ], + [ + "ve", + "a" + ], + [ + ".\\n */\\n function ", + "ceilDiv" + ], + [ + "contract", + "Token" + ], + [ + "In", + "side" + ], + [ + "Am", + "pl" + ], + [ + "****", + "*" + ], + [ + "Ex", + "change" + ], + [ + "token ", + "balance " + ], + [ + "token ", + "contracts " + ], + [ + "can ", + "use " + ], + [ + ").", + "\\n *\\n * " + ], + [ + "s[", + "_" + ], + [ + "buy", + "Marketing" + ], + [ + "` is ", + "additional data" + ], + [ + "sell", + "Marketing" + ], + [ + ") private ", + "{\\r\\n " + ], + [ + "must be ", + "an " + ], + [ + ", and ", + "can be used to " + ], + [ + "Con", + "structor" + ], + [ + "gen", + "cet" + ], + [ + "man", + "ifold" + ], + [ + ");\\n }\\n\\n ", + "//" + ], + [ + "two ", + "signed " + ], + [ + "(uint256 tokenId", + ") public view override returns (" + ], + [ + "posi", + "tive" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Returns the ", + "ceiling of the division of " + ], + [ + "ER_", + "B" + ], + [ + "And", + "Return" + ], + [ + "was ", + "not " + ], + [ + ".\\n *\\n * This ", + "differs from standard division with `/` in that it rounds up instead" + ], + [ + ", it ", + "has no " + ], + [ + "initializ", + "ed to " + ], + [ + "112", + "x112" + ], + [ + "NFT", + "s " + ], + [ + "10000", + "000" + ], + [ + "}, ", + "this imp" + ], + [ + "for (uint256 i", + "; i < " + ], + [ + "at the ", + "last " + ], + [ + "Al", + "gorithm" + ], + [ + "(`", + "_burn" + ], + [ + "{transferFrom", + "}, this imp" + ], + [ + "so ", + "it " + ], + [ + "Before", + "Swap" + ], + [ + "Data ", + "{\\n " + ], + [ + "_totalSupply ", + "= _totalSupply" + ], + [ + " F", + "UNCTION" + ], + [ + "PL-", + "2.0" + ], + [ + "specified ", + "format " + ], + [ + "perform ", + "token transfer, such as signature" + ], + [ + "Decim", + "al" + ], + [ + ", which is ", + "the " + ], + [ + "An ", + "empty " + ], + [ + "allow ", + "list " + ], + [ + "two numbers", + ".\\n *\\n * This differs from standard division with `/` in that it rounds up instead" + ], + [ + "internal function is equivalent to {", + "safeTransferFrom}" + ], + [ + "▓▓▓▓", + "▓▓▓▓" + ], + [ + ";\\n require(", + "c / a == b, \\\"SafeMath: multiplication overflow" + ], + [ + "\\n * of ", + "rounding down" + ], + [ + "burned ", + "(`_burn" + ], + [ + "info", + "." + ], + [ + "-name-mixed", + "case " + ], + [ + "toMask", + "ed" + ], + [ + "existing when they are ", + "burned (`_burn" + ], + [ + "complex", + " " + ], + [ + "Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approv", + "ing the\\n * zero " + ], + [ + "array, and it may change when more values are added or removed", + ".\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function " + ], + [ + "Note that there are no guarantees on the ordering of values inside ", + "the\\n * " + ], + [ + "interfaces/contracts/", + "solidity-utils/" + ], + [ + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b", + " - 1) / b can overflow on addition, so we distribute" + ], + [ + "and it is ", + "sent in " + ], + [ + "stop ", + "existing when they are burned (`_burn" + ], + [ + "projects[_projectId", + "]." + ], + [ + "necessarily ", + "me" + ], + [ + "saf", + "ety " + ], + [ + "MAN", + "AG" + ], + [ + "DOMAIN", + "_TYPEHASH" + ], + [ + ".\\n return (", + "a & b) + (a ^ b) / 2" + ], + [ + "midd", + "le " + ], + [ + "safeTransferFrom(from, to, tokenId, \\\"\\\"", + ");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function " + ], + [ + ").interfaceId ||\\n interfaceId == type(IERC721Metadata", + ").interfaceId ||\\n super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner" + ], + [ + "_msgSender() == owner || ", + "isApprovedForAll(owner, _msgSender())" + ], + [ + "return the current ", + "value and " + ], + [ + "diver", + "gencet" + ], + [ + "b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow", + ".\\n return (a & b) + (a ^ b) / 2" + ], + [ + "VAR", + "I" + ], + [ + "As opposed to ", + "{transferFrom}, this imp" + ], + [ + "implement alternative mechanisms to ", + "perform token transfer, such as signature" + ], + [ + ".\\n */\\n function ceilDiv", + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute" + ], + [ + "` is additional data", + ", it has no " + ], + [ + ";\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of ", + "two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead" + ], + [ + "PL-2.0", + "-or-later" + ], + [ + "specified format ", + "and it is sent in " + ], + [ + "internal function is equivalent to {safeTransferFrom}", + ", and can be used to " + ], + [ + "\\n * of rounding down", + ".\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute" + ], + [ + "Note that there are no guarantees on the ordering of values inside the\\n * ", + "array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function " + ], + [ + "divergencet", + "ech/" + ], + [ + "b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2", + ";\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead" + ], + [ + "As opposed to {transferFrom}, this imp", + "oses no restrictions on msg.sender" + ], + [ + "implement alternative mechanisms to perform token transfer, such as signature", + "-based" + ], + [ + "` is additional data, it has no ", + "specified format and it is sent in " + ], + [ + "\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute", + ".\\n return " + ], + [ + "b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2;\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead", + "\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute.\\n return " + ], + [ + "'", + ",\\n '" + ], + [ + "(", + "i" + ], + [ + "(", + "block.timestamp" + ], + [ + ".", + "transfer" + ], + [ + ".", + "supportsInterface(interfaceId" + ], + [ + ".", + "xyz" + ], + [ + "G", + "iven " + ], + [ + "P", + "end" + ], + [ + "S", + "qrt" + ], + [ + "_", + "require" + ], + [ + "_", + "TH" + ], + [ + "_", + "admin" + ], + [ + "b", + "ecause the " + ], + [ + "d", + "st " + ], + [ + "f", + "ound " + ], + [ + "i", + "ble" + ], + [ + "s", + "lippage " + ], + [ + "╬", + "╣" + ], + [ + "al", + "ter" + ], + [ + "en", + "ari" + ], + [ + "on", + "ERC1155" + ], + [ + "address", + ") {\\n return _" + ], + [ + "uint256 ", + "amount" + ], + [ + "si", + "re" + ], + [ + ");\\n ", + "} else {\\n return " + ], + [ + "in ", + "un" + ], + [ + ". ", + "W" + ], + [ + "} ", + "whenever possible" + ], + [ + ") external ", + "{\\n " + ], + [ + ") public ", + "returns (bool" + ], + [ + "'s ", + "gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status" + ], + [ + "gr", + "ou" + ], + [ + "@param", + " b" + ], + [ + "cannot be ", + "zero " + ], + [ + "returns (bool", + ")\\n {\\n return " + ], + [ + "uint8", + " _" + ], + [ + "00000000", + "0000" + ], + [ + "].", + "length" + ], + [ + "using ", + "Counters for Counters.Counter" + ], + [ + "before", + "Fallback" + ], + [ + "man", + "age" + ], + [ + "super", + ".safeTransferFrom" + ], + [ + ");\\r\\n", + " }\\r\\n" + ], + [ + "(address indexed ", + "account" + ], + [ + "ed in ", + "{" + ], + [ + "Role(", + "DEFAULT_ADMIN_ROLE" + ], + [ + ".\\n *\\n * ", + "@dev " + ], + [ + "gas ", + "during " + ], + [ + "sol", + "d " + ], + [ + "We ", + "know " + ], + [ + "recover", + "y " + ], + [ + "about ", + "to be transferred" + ], + [ + "(from, to, tokenId", + ", data" + ], + [ + "does not ", + "necessarily me" + ], + [ + "have been ", + "transferred" + ], + [ + "delegate ", + "call failed\"" + ], + [ + "let ", + "f := " + ], + [ + "amount of tokens ", + "to " + ], + [ + "\\n returns (", + "uint256" + ], + [ + ".sol\\\";\\n\\n", + "import {" + ], + [ + "_safeMint", + "} whenever possible" + ], + [ + "- 1", + ") / b" + ], + [ + "slot ", + "(" + ], + [ + "over ", + "time" + ], + [ + "mint to ", + "the zero address\\\");\\n require(" + ], + [ + "s with ", + "custom message " + ], + [ + "getAmount", + "Out" + ], + [ + "Revert", + "s with custom message " + ], + [ + "invariant", + "Ratio" + ], + [ + ") {\\n ", + "require(" + ], + [ + "multip", + "li" + ], + [ + "token/ERC721/extensions/", + "ERC721Enumerable" + ], + [ + "\"Address: low-level ", + "delegate call failed\"" + ], + [ + "cas", + "es, " + ], + [ + "\"// SPDX-License-Identifier: G", + "PL-2.0-or-later" + ], + [ + "conver", + "ges " + ], + [ + ".\\n */\\n function get", + "RoleMember" + ], + [ + ");\\n return (", + "spender" + ], + [ + "sk", + "ip" + ], + [ + "OOOOOOOO", + "OOOOOOOO" + ], + [ + "bptAmount", + "Out" + ], + [ + "136", + "3" + ], + [ + ".sol\\\";\\r\\n", + "import \\\"./" + ], + [ + "⣿⣿⣿⣿", + "⣿⣿⣿⣿" + ], + [ + ", ERC165", + " {\\n struct " + ], + [ + "1,\\n 1,\\n ", + "1,\\n 1,\\n " + ], + [ + "mission", + "s" + ], + [ + "Emit ", + "an " + ], + [ + "dynam", + "ically " + ], + [ + "slot's ", + "contents, replace the bits taken up by the boolean, and then write\\n // back. This is the " + ], + [ + "Enumerable ", + "extension" + ], + [ + "Nominal", + "Main" + ], + [ + "nonces(address owner", + ") external view returns (uint256" + ], + [ + "PaymentSplitter", + ": " + ], + [ + "El", + "astic" + ], + [ + "Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator", + ") external view returns (bool" + ], + [ + "ERC721-", + "_safeMint" + ], + [ + "(address owner) internal view returns (uint256) {\\n return ", + "(_packedAddressData[owner] >> _" + ], + [ + "set._inner, value", + ");\\n }\\n\\n /**\\n * @dev " + ], + [ + "(account, address(0), amount);\\n\\n _afterTokenTransfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(\\n address owner,\\n address spender,\\n uint256 amount\\n ) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev ", + "Updates `owner` s allowance for `spender` based on spent `amount`.\\n *\\n * Does not update the allowance amount in case of infinite allowance.\\n * Revert if not enough allowance is available.\\n *\\n * Might emit an {Approval} event.\\n */\\n function _spendAllowance" + ], + [ + "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline", + ")\\\"" + ], + [ + "compiler's ", + "defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction" + ], + [ + "override(ERC165, IERC165", + ") returns (bool) {\\n return\\n interfaceId == type(IERC721" + ], + [ + "getRoleMemberCount", + "}, " + ], + [ + "baseToken", + "For" + ], + [ + "tmp", + "Success" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative", + ").\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub" + ], + [ + "`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to ", + "move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId" + ], + [ + "basic", + "Transfer" + ], + [ + "of data (0, since no data).", + "\\n " + ], + [ + "possi", + "bility " + ], + [ + " is Context, ERC165, IERC721", + ", IERC721Metadata {\\n using Address for address;\\n using Strings for uint256" + ], + [ + "`).\\n */\\n function _", + "exists(uint256 tokenId" + ], + [ + "burnFrom(address account, uint256 amount", + ") public virtual " + ], + [ + " of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+", + "` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add" + ], + [ + "Guarant", + "eed" + ], + [ + "integer division of two unsigned integ", + "ers. " + ], + [ + "accounts that have `role", + "`. " + ], + [ + "Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ", + "ReentrancyGuard {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // " + ], + [ + "slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the ", + "compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction" + ], + [ + "slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction", + "'s gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status" + ], + [ + "0", + "2" + ], + [ + "0", + "c" + ], + [ + "1", + "b" + ], + [ + ":", + "°" + ], + [ + ":", + "\\n // " + ], + [ + "D", + "esc" + ], + [ + "]", + ";\\n" + ], + [ + "_", + "pre" + ], + [ + "_", + "grantRole" + ], + [ + "_", + "digitalMedia" + ], + [ + "a", + "50" + ], + [ + "n", + " = " + ], + [ + "v", + "5" + ], + [ + "w", + "idth" + ], + [ + "°", + ":" + ], + [ + "•", + ".°" + ], + [ + "•", + "°:" + ], + [ + "\\n ", + ") public " + ], + [ + "un", + "owned" + ], + [ + "return", + "s a " + ], + [ + "To", + "Caller" + ], + [ + ") {\\n ", + "this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691" + ], + [ + "Address", + "Set " + ], + [ + "max", + "Total" + ], + [ + "token ", + "that " + ], + [ + "IERC20", + "(token" + ], + [ + "check", + " for " + ], + [ + "the", + "\\n // " + ], + [ + "0x", + "1" + ], + [ + "_owner", + "Of" + ], + [ + "tokens", + ", " + ], + [ + "ed by ", + "user" + ], + [ + "Index", + " = " + ], + [ + ".\\n */\\n function _", + "isApprovedOrOwner" + ], + [ + "` cannot be the zero address", + ".\\r\\n * - `" + ], + [ + "Interfac", + "es" + ], + [ + "Sel", + "f" + ], + [ + "0, ", + "1, 2, " + ], + [ + "typ", + "ically " + ], + [ + ".\\n * ", + "It " + ], + [ + "\\\");\\n\\n ", + "require(\\n " + ], + [ + "&&", + "\\n " + ], + [ + "src", + ", " + ], + [ + "out", + "side " + ], + [ + "er is not ", + "a " + ], + [ + "; // ", + "2" + ], + [ + "temp", + "Uint" + ], + [ + "deploy", + "er" + ], + [ + ") internal virtual {\\n ", + "_transfer(from, to, tokenId" + ], + [ + "_address", + "es" + ], + [ + "-address-", + "uint256-}[`" + ], + [ + "Liqui", + "dation" + ], + [ + "_tokenId", + "s" + ], + [ + "uint256[] memory ", + "balances" + ], + [ + ");\\n require(", + "to != owner" + ], + [ + ", but ", + "not " + ], + [ + "reasur", + "y " + ], + [ + "_safeMint", + "`], " + ], + [ + "slot ", + "of the " + ], + [ + "` operator.\\n *\\n * Requirements:\\n *\\n * - ", + "Multiplication cannot overflow.\\n */\\n function mul" + ], + [ + "IERC721Receiver-onERC721Received", + "} to " + ], + [ + "safe ", + "transfer" + ], + [ + "\\\");", + "\\r\\n " + ], + [ + "royalty ", + "fee " + ], + [ + "start ", + "of " + ], + [ + "UP", + "P" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist", + ".\\n */\\n function _isApprovedOrOwner" + ], + [ + "small", + "er than the " + ], + [ + "owned by `from`.\\n * - ", + "If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _" + ], + [ + "add ", + "a " + ], + [ + "Destroy", + "s `amount` tokens from the caller" + ], + [ + "part ", + "of a " + ], + [ + "with an ", + "additional " + ], + [ + "`)", + ",\\n * and " + ], + [ + "`.\\n *\\n * This ", + "internal function is equivalent to {safeTransferFrom}, and can be used to " + ], + [ + "squ", + "a" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be ", + "owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _" + ], + [ + "forward", + "ed in {" + ], + [ + "{\\r\\n require(", + "\\r\\n " + ], + [ + "behavior ", + "in " + ], + [ + "Approve", + "ToCaller" + ], + [ + "circ", + "u" + ], + [ + "transfer to non ERC721Receiver implementer", + "\"" + ], + [ + ");\\n\\n /// @notice ", + "The " + ], + [ + "uint8) {\\n return ", + "_decimals" + ], + [ + "Det", + "ail" + ], + [ + "();\\n if (", + "quantity == 0) revert MintZeroQuantity" + ], + [ + "Fund", + "ing" + ], + [ + "ToZeroAddress", + "();\\n if (quantity == 0) revert MintZeroQuantity" + ], + [ + ".*", + ":" + ], + [ + ".*", + "•´" + ], + [ + "At ", + "this point" + ], + [ + ", \\\"ERC721: ", + "approval to current owner" + ], + [ + "`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked", + ".\\n *\\n * `" + ], + [ + "*.", + "´" + ], + [ + "`tokenId`", + ".\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner" + ], + [ + "parameter ", + "which " + ], + [ + "(address owner, address spender, uint256 amount", + ") internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev " + ], + [ + "programm", + "ing " + ], + [ + "if (!_exists(tokenId)) revert ", + "URIQueryForNonexistentToken" + ], + [ + "byte(", + "0, " + ], + [ + ".\\n * ", + "As opposed to {transferFrom}, this imposes no restrictions on msg.sender" + ], + [ + ";\\n\\n /**\\n * @dev Initializes the contract ", + "by setting a `name` and a `symbol` to the token collection" + ], + [ + "_approve(to, tokenId", + ");\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved" + ], + [ + "\\n view", + "\\n returns (" + ], + [ + "record ", + "of " + ], + [ + "batch ", + "mint" + ], + [ + "\\r\\n /**\\r\\n * ", + "@dev " + ], + [ + "_tokenApprovals[tokenId] = to", + ";\\n emit Approval(" + ], + [ + "_AL", + "LOW" + ], + [ + "\\\\xe5", + "\\\\x" + ], + [ + "Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint", + "`),\\n * and " + ], + [ + "keccak256(abi.encodePacked(\\\"\\\\x19\\\\x01", + "\\\", " + ], + [ + "allowed SeaDrop contract", + ".\\n * @param " + ], + [ + ";\\n\\n/*", + "\\n * @dev " + ], + [ + "call to `to", + "`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to " + ], + [ + "e.g.\\n * ", + "implement alternative mechanisms to perform token transfer, such as signature-based" + ], + [ + "1 word ", + "for the " + ], + [ + "`data` ", + "parameter which " + ], + [ + "_balances[account] += amount;\\n emit Transfer(address(0), account, amount);\\n\\n _afterTokenTransfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n unchecked {\\n _balances[account] = accountBalance - amount", + ";\\n }\\n _totalSupply -= amount;\\n\\n emit Transfer" + ], + [ + "Returns whether `spender` is allowed to manage ", + "`tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner" + ], + [ + "` is additional data, it has no specified format and it is sent in ", + "call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to " + ], + [ + "ERC721-_safeMint", + "-address-uint256-}[`" + ], + [ + ":°", + "•.°" + ], + [ + "Desc", + "ri" + ], + [ + "_safeMint`], ", + "with an additional " + ], + [ + "IERC721Receiver-onERC721Received} to ", + "contract recipient" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _", + "safeTransfer" + ], + [ + "forwarded in {", + "IERC721Receiver-onERC721Received} to contract recipient" + ], + [ + ".*•´", + ".*:" + ], + [ + "Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and ", + "stop existing when they are burned (`_burn" + ], + [ + "e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based", + ".\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer" + ], + [ + "Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner", + "(address spender, uint256 tokenId" + ], + [ + "` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to ", + "e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer" + ], + [ + "ERC721-_safeMint-address-uint256-}[`", + "_safeMint`], with an additional " + ], + [ + "ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional ", + "`data` parameter which " + ], + [ + ".", + "total" + ], + [ + "/", + "\"" + ], + [ + "B", + "ulk" + ], + [ + "C", + "C" + ], + [ + "F", + "ailed" + ], + [ + "_", + "gauge" + ], + [ + "c", + "ancel" + ], + [ + "e", + "co" + ], + [ + "f", + "our" + ], + [ + "k", + "it" + ], + [ + "o", + "z" + ], + [ + "s", + "g" + ], + [ + "s", + "\\\":" + ], + [ + "x", + "p" + ], + [ + "\\n ", + ") internal virtual {\\n require(" + ], + [ + "or", + "ari" + ], + [ + "ing", + "\\n // " + ], + [ + "ar", + "tist " + ], + [ + "\\\"", + ") {" + ], + [ + "is ", + "un" + ], + [ + "is ", + "now " + ], + [ + ".s", + "end" + ], + [ + "an ", + "emergency " + ], + [ + "\\n * ", + "the " + ], + [ + " = ", + "IUniswapV2Factory" + ], + [ + ". ", + "Throws if " + ], + [ + "In", + "vocation" + ], + [ + "value ", + "does not necessarily me" + ], + [ + " _", + "____" + ], + [ + "0x", + "60" + ], + [ + "will ", + "exceed " + ], + [ + "IP", + "ancake" + ], + [ + "Safe", + "Transfer" + ], + [ + "safe", + "Sub" + ], + [ + "Un", + "locked" + ], + [ + "sell", + "Tax" + ], + [ + "0, ", + "0" + ], + [ + ".\\n * - `", + "to` cannot be the zero address" + ], + [ + "sc", + "enari" + ], + [ + ") public virtual ", + "{\\n require(" + ], + [ + "row", + "d" + ], + [ + ")\\\", p0", + "));\\n\\t\\tignored;\\n\\t}\\n\\n\\tfunction " + ], + [ + "update", + "Reward" + ], + [ + "multi", + "Proof" + ], + [ + "struct ", + "value does not necessarily me" + ], + [ + "p0", + ") internal view {\\n\\t\\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature(\\\"log(" + ], + [ + "_msgSender()", + ");\\n }\\n\\n /**\\n * @dev " + ], + [ + ", uint ", + "reserveOut" + ], + [ + "Be", + "ar" + ], + [ + "inter", + "pre" + ], + [ + "_total", + "Minted(" + ], + [ + "ownership ", + "details" + ], + [ + "admin ", + "to " + ], + [ + "their ", + "own" + ], + [ + "||", + "\\n " + ], + [ + "AP", + "PRO" + ], + [ + ") {\\n _", + "status = _NOT_ENTERED" + ], + [ + "values ", + "in the " + ], + [ + "way to ", + "retrieve " + ], + [ + "token is ", + "unowned" + ], + [ + "lower ", + "gas during " + ], + [ + "))\\n ", + "}\\n }\\n " + ], + [ + "list ", + "of the " + ], + [ + "s in ", + "Solidity " + ], + [ + "dstRep", + "Old" + ], + [ + "malle", + "able" + ], + [ + "(uint256 tokenId) public view virtual override returns (", + "address" + ], + [ + "].add(", + "addedValue" + ], + [ + "separat", + "ely " + ], + [ + "be\\n * ", + "re" + ], + [ + "r` and `", + "s" + ], + [ + "uint256(_", + "addressData[owner]." + ], + [ + "sale ", + "price" + ], + [ + "token/ERC721/extensions/IERC721Metadata", + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../" + ], + [ + "LIC", + "ENS" + ], + [ + "loop", + " " + ], + [ + "high ", + "level " + ], + [ + "uint112 ", + "reserve0, " + ], + [ + "modulo by ", + "zero" + ], + [ + "var", + "-name-mixedcase " + ], + [ + "isexemptfrom", + "fees" + ], + [ + "\\\"\\n );\\n\\n ", + "_approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved" + ], + [ + "tokenId` must not exist", + ".\\n * - `to` cannot be the zero address" + ], + [ + "launched", + "At" + ], + [ + "structs/", + "EnumerableSet" + ], + [ + "standardized ", + "way to retrieve " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Approve ", + "`to` to operate on `tokenId`" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to", + "`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `" + ], + [ + "DEC", + "IMAL" + ], + [ + "deb", + "t " + ], + [ + " batch ", + "size" + ], + [ + "implementation for ", + "details." + ], + [ + ";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId", + ") public virtual override {\\n " + ], + [ + "\\n *\\n * Requirements:\\n *\\n * - `", + "tokenId` must not exist.\\n * - `to` cannot be the zero address" + ], + [ + "Burnable is ", + "Context" + ], + [ + "dynamic", + "LiquidityFee" + ], + [ + "an the ", + "token is unowned" + ], + [ + "recipient` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(_msgSender(), recipient, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n _approve(_msgSender(), spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20", + "}.\\n *\\n * Requirements:\\n *\\n * - `sender` and `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``sender``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom" + ], + [ + "ffffffffffffffffffffffffffffffffffffffffffffffffffffffff", + "fffffff" + ], + [ + "if (to.isContract()", + ") {\\n " + ], + [ + "_safeMint(to, tokenId", + ", \\\"\\\"" + ], + [ + ")\\n );\\n\\n // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .\\n if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED", + " == 0) {\\n uint256 nextTokenId = tokenId + 1;\\n // If the next slot's address is zero and not burned (i.e. packed value is zero).\\n if (_packedOwnerships[nextTokenId] == 0) {\\n // If the next slot is within bounds.\\n if (nextTokenId != _currentIndex) {\\n // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.\\n _packedOwnerships[nextTokenId] = prevOwnershipPacked;\\n }\\n }\\n }\\n }\\n\\n emit Transfer" + ], + [ + "incredibly unrealistic", + ".\\n // " + ], + [ + "An empty ", + "struct value does not necessarily me" + ], + [ + "divergencetech/", + "ethier" + ], + [ + "_safeMint} whenever possible", + "\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address" + ], + [ + "override(ERC165, IERC165) returns (bool) {\\n return\\n interfaceId == type(IERC721", + ").interfaceId ||\\n interfaceId == type(IERC721Metadata).interfaceId ||\\n super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner" + ], + [ + "Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn", + "`).\\n */\\n function _exists(uint256 tokenId" + ], + [ + "multiProof", + "Verify" + ], + [ + ") {\\n _status = _NOT_ENTERED", + ";\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and " + ], + [ + "lower gas during ", + "batch mint" + ], + [ + "uint112 reserve0, ", + "uint112 reserve1" + ], + [ + "standardized way to retrieve ", + "royalty payment" + ], + [ + "An empty struct value does not necessarily me", + "an the token is unowned" + ], + [ + " ", + "2" + ], + [ + " ", + "public " + ], + [ + " ", + "information" + ], + [ + "-", + "only" + ], + [ + "N", + "orm" + ], + [ + "Q", + "ty" + ], + [ + "_", + "recipient" + ], + [ + "_", + "hash" + ], + [ + "_", + "safeTransfer" + ], + [ + "_", + "srcChainId" + ], + [ + "`", + "\\n " + ], + [ + "e", + "^" + ], + [ + "m", + "y" + ], + [ + "r", + "." + ], + [ + "al", + "\\n * " + ], + [ + "\\n ", + "@notice " + ], + [ + ", ", + "uint32 " + ], + [ + "fun", + "gi" + ], + [ + "ver", + "sa" + ], + [ + "address ", + "addr" + ], + [ + "owner", + "_" + ], + [ + "public", + " " + ], + [ + "require", + " " + ], + [ + "an ", + "overflow " + ], + [ + "Ad", + "v" + ], + [ + "\\n\\n", + "pragma solidity >=" + ], + [ + "in ", + "which " + ], + [ + "in ", + "bugs, " + ], + [ + ". ", + "However" + ], + [ + "get", + "Pool" + ], + [ + "get", + "ChainId" + ], + [ + "require(", + "denominator" + ], + [ + "error", + ", which is the " + ], + [ + "Tokens", + "BeforeSwap" + ], + [ + "Se", + "tup" + ], + [ + "with ", + "0x" + ], + [ + ");\\n }\\n\\n /**\\n * @dev ", + "Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId" + ], + [ + "bytes ", + "of " + ], + [ + ";\\n }\\n\\n /**\\n * @dev ", + "Modifier to make a function callable only when the " + ], + [ + "per", + "man" + ], + [ + "Per", + "p" + ], + [ + "RE", + "S" + ], + [ + "using ", + "SafeMath for uint256" + ], + [ + "ED", + " " + ], + [ + "ownership", + "-" + ], + [ + "}.\\n */\\n function ", + "burn(uint256 amount" + ], + [ + "_mint", + "ers" + ], + [ + "IUniswapV2", + "Factory " + ], + [ + "denominator", + ", " + ], + [ + "denominator", + " == 0" + ], + [ + "_to", + "Address" + ], + [ + ");\\r\\n", + "\\r\\n /**\\r\\n * @dev Returns the " + ], + [ + "app", + "ly" + ], + [ + "Deleg", + "ate " + ], + [ + "gas ", + "saving" + ], + [ + "We ", + "need to " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Same as {xref-", + "ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which " + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (", + "token/ERC721/extensions/IERC721Metadata.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../" + ], + [ + "writ", + "e the " + ], + [ + "initializ", + "ation " + ], + [ + "larg", + "er than " + ], + [ + "because ", + "programm" + ], + [ + "Factor", + " " + ], + [ + "standard ", + "behavior in " + ], + [ + "} event.\\n */\\n function _", + "approve(address to, uint256 tokenId) internal virtual {\\n " + ], + [ + "enti", + "al " + ], + [ + "` must be ", + "a " + ], + [ + "ers ", + "usually " + ], + [ + "is\\n * ", + "forwarded in {IERC721Receiver-onERC721Received} to contract recipient" + ], + [ + "request", + "Id" + ], + [ + "EIP712", + " " + ], + [ + "marketingWallet", + "Updated" + ], + [ + ".\\n */\\nabstract contract ", + "AccessControl" + ], + [ + ".\\n * - ", + "If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _" + ], + [ + "EIP-", + "17" + ], + [ + "\\r\\n ", + "'" + ], + [ + "enumer", + "ation " + ], + [ + "lower ", + "half order" + ], + [ + "domainSeparator", + ", " + ], + [ + "\\n */\\ncontract ", + "ERC721" + ], + [ + "ERC721.ownerOf(tokenId", + ") == from, \\\"ERC721: " + ], + [ + ") {\\n value /= ", + "10 ** " + ], + [ + ";\\n }\\n if (value >= ", + "10 ** " + ], + [ + "tack", + "exchange." + ], + [ + "assume that ", + "an overflow " + ], + [ + "Hand", + "le " + ], + [ + "those ", + "that " + ], + [ + ");\\n\\n // Clear approval", + "s\\n " + ], + [ + "bytes32 private ", + "immutable " + ], + [ + "`.\\n *\\n * WARNING: Usage of this method is discouraged, use {", + "_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address" + ], + [ + "token/ERC721/IERC721Receiver", + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title " + ], + [ + "to == address(0)", + ") revert Mint" + ], + [ + ";\\n }\\n", + "}\\n\\n" + ], + [ + "expi", + "res" + ], + [ + "proper", + "ly " + ], + [ + "tic operation", + "s in Solidity " + ], + [ + "Params ", + "memory " + ], + [ + "pend", + "le" + ], + [ + ";\\r\\n ", + "result += " + ], + [ + "tokenId` must not exist", + ".\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _" + ], + [ + "to != address(0), \\\"ERC721: ", + "mint to the zero address\\\");\\n require(" + ], + [ + "s `tokenId` and transfers it to `to", + "`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address" + ], + [ + "starts ", + "off " + ], + [ + "od", + "d " + ], + [ + "rais", + "es " + ], + [ + "== 0) {\\n return 0;\\n ", + "}\\n\\n // " + ], + [ + "compati", + "ble " + ], + [ + "token holder", + "s to " + ], + [ + "ByOwner", + "Or" + ], + [ + "outcom", + "e " + ], + [ + "`SafeMath", + "` restores this int" + ], + [ + "OUT_", + "OF" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`", + ".\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender" + ], + [ + "ui", + "tion by " + ], + [ + "on overflow. This ", + "can easily " + ], + [ + ";\\r\\n }\\r\\n ", + "if (value " + ], + [ + "\"Amount ", + "must be less than " + ], + [ + "parti", + "al " + ], + [ + "wrap ", + "on overflow. This can easily " + ], + [ + "Fra", + "x" + ], + [ + "by subtrac", + "ting the " + ], + [ + "/256 bits", + "\\n " + ], + [ + "Por", + "tion" + ], + [ + "esti", + "ma" + ], + [ + "Arithme", + "tic operations in Solidity " + ], + [ + "Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuard {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // ", + "slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status" + ], + [ + ");\\n require(to != owner", + ", \\\"ERC721: approval to current owner" + ], + [ + "programming ", + "langu" + ], + [ + "high level ", + "programming langu" + ], + [ + "in bugs, ", + "because programm" + ], + [ + "error, which is the ", + "standard behavior in " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which ", + "is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipient" + ], + [ + "} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n ", + "_tokenApprovals[tokenId] = to;\\n emit Approval(" + ], + [ + "ers usually ", + "assume that an overflow " + ], + [ + "tackexchange.", + "com/" + ], + [ + "`SafeMath` restores this int", + "uition by " + ], + [ + "wrap on overflow. This can easily ", + "result" + ], + [ + "Arithmetic operations in Solidity ", + "wrap on overflow. This can easily result" + ], + [ + "in bugs, because programm", + "ers usually assume that an overflow " + ], + [ + "error, which is the standard behavior in ", + "high level programming langu" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipient", + "s" + ], + [ + "`SafeMath` restores this intuition by ", + "reverting the transaction when " + ], + [ + "in bugs, because programmers usually assume that an overflow ", + "raises " + ], + [ + "\"", + "ipf" + ], + [ + "#", + "*" + ], + [ + ")", + "/" + ], + [ + "+", + "1)" + ], + [ + ".", + "div" + ], + [ + "1", + "16" + ], + [ + "B", + "ecause the " + ], + [ + "E", + "M" + ], + [ + "_", + ";\\n " + ], + [ + "_", + "previousOwner" + ], + [ + "_", + "squa" + ], + [ + "`", + "bytes4(" + ], + [ + "b", + " = " + ], + [ + "b", + "yp" + ], + [ + "c", + "red" + ], + [ + "m", + "ight " + ], + [ + "n", + "u" + ], + [ + "q", + "r" + ], + [ + "x", + "^" + ], + [ + "x", + " >= " + ], + [ + "z", + "_squa" + ], + [ + "\\n ", + "int256 constant " + ], + [ + "re", + "pl" + ], + [ + "s ", + "<= " + ], + [ + " *", + "*******" + ], + [ + "uint256", + ") public " + ], + [ + "tr", + "ad" + ], + [ + "qu", + "ad" + ], + [ + "address ", + "cannot be " + ], + [ + "address ", + "receiver" + ], + [ + "To", + "Send" + ], + [ + ": ", + "decrement" + ], + [ + ",\\n ", + "uint256" + ], + [ + "um", + "b" + ], + [ + "ERC721", + "Burnable" + ], + [ + "pro", + "venance " + ], + [ + "true", + ", 0" + ], + [ + ") external ", + "view override returns (" + ], + [ + "current", + "BaseURI" + ], + [ + "length", + " in " + ], + [ + ";\\n\\n ", + "struct " + ], + [ + ").", + "\\n */\\ncontract " + ], + [ + "bytes32 ", + "public " + ], + [ + "\\n ", + "* " + ], + [ + "supp", + "lied " + ], + [ + "10", + "%" + ], + [ + "\\n ", + "abi.encodePacked(" + ], + [ + "(_", + "amount" + ], + [ + "Pro", + "vid" + ], + [ + "18", + "0" + ], + [ + " != ", + "end" + ], + [ + "0 ", + "< " + ], + [ + "\\\\", + "_" + ], + [ + ".sol\\\";\\nimport \\\"", + "@" + ], + [ + "Paus", + "able " + ], + [ + "Counter", + ": decrement" + ], + [ + "OpenZeppelin ", + "guidelines: functions " + ], + [ + "][", + "_" + ], + [ + "OwnershipTransferred", + "(address(0), " + ], + [ + ",\\n address to,\\n uint256 ", + "value\\n ) internal {\\n " + ], + [ + "last", + "Claim" + ], + [ + "last", + "Update" + ], + [ + "down", + " " + ], + [ + "0) {\\n ", + "return " + ], + [ + "Us", + "e the " + ], + [ + ") internal virtual {\\n ", + "_safeMint(to, tokenId, \\\"\\\"" + ], + [ + " = _", + "allTokens" + ], + [ + "Upgrade", + "able is " + ], + [ + "_buy", + "er" + ], + [ + "assembly {", + "\\n " + ], + [ + "Updated", + "Max" + ], + [ + "\\u0027", + ");\\n " + ], + [ + "== 0", + ") return (" + ], + [ + "reason", + ".length == 0) {\\n " + ], + [ + "Thres", + "hold " + ], + [ + "delete ", + "token" + ], + [ + "(address target, bytes memory data", + ", string memory errorMessage" + ], + [ + "The", + "ore" + ], + [ + "_B", + "OUND" + ], + [ + ") >> ", + "128" + ], + [ + "} else {\\n ", + "return true" + ], + [ + "ched", + "ul" + ], + [ + "uint24", + "8" + ], + [ + "maximum ", + "mint" + ], + [ + "startTimestamp", + "` " + ], + [ + "Invariant", + "(" + ], + [ + "Rel", + "ay" + ], + [ + "ONE_", + "36" + ], + [ + "80", + "4" + ], + [ + "Slot ", + "= " + ], + [ + "Author", + "ized" + ], + [ + "necess", + "ary " + ], + [ + "\\n // ", + "(i.e. `ownership.addr" + ], + [ + ", \\\"SafeMath: ", + "modulo by zero" + ], + [ + "cach", + "ed " + ], + [ + "computedHash", + " = _" + ], + [ + "(int256 ", + "a, int256 b) internal pure returns (int256" + ], + [ + "Requirements:\\r\\n *\\r", + "\\n * - `" + ], + [ + "tradingActive", + "Block" + ], + [ + "there is ", + "no " + ], + [ + "lower than ", + "0.5" + ], + [ + "256 ", + "by " + ], + [ + "JSON", + " " + ], + [ + "early", + "Sell" + ], + [ + "Stable", + "Pool" + ], + [ + "signature is ", + "valid " + ], + [ + ". Since ", + "the " + ], + [ + "c / ", + "a != " + ], + [ + "lower than 0.", + "001" + ], + [ + "AAAA", + "AAAA" + ], + [ + "to != address(0), \\\"ERC721: ", + "transfer to the zero address\\\");\\n\\n _beforeTokenTransfer" + ], + [ + "O(1) ", + "time " + ], + [ + ".\\n *\\n * See {ERC20-_burn", + "}.\\n */\\n function burn(uint256 amount" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Safely mint", + "s `tokenId` and transfers it to `to" + ], + [ + "uint256) {\\n if (", + "owner == address(0)) revert " + ], + [ + "token/ERC20/extensions/draft-", + "IERC20Permit" + ], + [ + ";\\n\\nimport './", + "IERC721A" + ], + [ + " * 10**", + "_decimals" + ], + [ + "VERY IMPORTANT: UNCOMMENT THIS LATER", + "\\n // " + ], + [ + "();\\n\\n _beforeTokenTransfers(address(0), to, startTokenId, quantity);\\n\\n // Overflows are ", + "incredibly unrealistic.\\n // " + ], + [ + "token gated ", + "drop " + ], + [ + "umentation ", + "for " + ], + [ + "due", + "ProtocolFee" + ], + [ + ".\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint", + "(address to, uint256 tokenId" + ], + [ + "CONSTRUCT", + "OR" + ], + [ + "reeding", + "Event" + ], + [ + "safeMint(address to, uint256 tokenId", + ") internal virtual {\\n _safeMint(to, tokenId, \\\"\\\"" + ], + [ + "[to] += quantity * ((1 << _", + "BITPOS_NUMBER_MINTED) | 1);\\n\\n // Updates:\\n // - `address` to the owner.\\n // - `startTimestamp` to the timestamp of minting.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `quantity == 1`.\\n _packedOwnerships[startTokenId] = _packOwnershipData(\\n to,\\n _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)\\n " + ], + [ + ".\\n unchecked {\\n // Updates:\\n // - `balance += quantity`.\\n // - `numberMinted += quantity`.\\n //\\n // We can directly add to the `balance` and `numberMinted`.\\n _packedAddressData", + "[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);\\n\\n // Updates:\\n // - `address` to the owner.\\n // - `startTimestamp` to the timestamp of minting.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `quantity == 1`.\\n _packedOwnerships[startTokenId] = _packOwnershipData(\\n to,\\n _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)\\n " + ], + [ + "(\\n bytes32 poolId", + ",\\n address " + ], + [ + "At this point", + " `" + ], + [ + "to == address(0)) revert Mint", + "ToZeroAddress();\\n if (quantity == 0) revert MintZeroQuantity" + ], + [ + "tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _", + "safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\"" + ], + [ + "s `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address", + ".\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId" + ], + [ + "OpenZeppelin guidelines: functions ", + "revert " + ], + [ + "== 0) return (", + "true, 0" + ], + [ + "c / a != ", + "b" + ], + [ + "tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\"", + ");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients" + ], + [ + " ", + "value: " + ], + [ + " ", + "& 0x" + ], + [ + ".", + "\\n */\\n " + ], + [ + "2", + "b" + ], + [ + "2", + "0000000" + ], + [ + "5", + "a" + ], + [ + "F", + "raction" + ], + [ + "P", + "T" + ], + [ + "Y", + "_" + ], + [ + "_", + "approved" + ], + [ + "_", + "upgradeTo" + ], + [ + "a", + "5" + ], + [ + "p", + "tion " + ], + [ + "\\n ", + "emit " + ], + [ + "in", + "ce" + ], + [ + ", ", + "token" + ], + [ + ", ", + "in a " + ], + [ + "is", + "Valid" + ], + [ + "is", + "TxLimit" + ], + [ + "co", + "gn" + ], + [ + "anc", + "e(" + ], + [ + "00", + ", 0x" + ], + [ + ": ", + "INSUFFICIENT" + ], + [ + " = ", + "new" + ], + [ + "Fee", + "Amount" + ], + [ + "In", + "flation" + ], + [ + " to ", + "delete" + ], + [ + " of ", + "this " + ], + [ + ") external ", + "view returns(" + ], + [ + "as ", + "tokens " + ], + [ + "only", + "Role" + ], + [ + "For", + "ward" + ], + [ + "red", + "uce" + ], + [ + "}\\n", + "\\n if (" + ], + [ + "ist", + "er " + ], + [ + "tokens ", + "list of the " + ], + [ + "bytes32 ", + "hash" + ], + [ + "s[", + "to" + ], + [ + "tokens", + ",\\n * " + ], + [ + "old", + "Address" + ], + [ + "] = ", + "tokenIndex" + ], + [ + "`.", + "\\n * @param _" + ], + [ + "have ", + "more than " + ], + [ + ";\\n ", + "} catch (bytes memory reason" + ], + [ + "(_", + "to" + ], + [ + "\\r\\n * ", + "`" + ], + [ + "` is ", + "a " + ], + [ + "Pro", + "duc" + ], + [ + "sell", + "er" + ], + [ + "col", + "lat" + ], + [ + "sc", + "r" + ], + [ + "used ", + "in the " + ], + [ + "last", + "ProcessedIndex" + ], + [ + "Transaction", + " " + ], + [ + "uint16", + "0 " + ], + [ + "(uint256 tokenId", + ", uint256 " + ], + [ + "buffer", + "Period" + ], + [ + "; // ", + "Update the " + ], + [ + "gas ", + "cost of " + ], + [ + "owner ", + "cannot " + ], + [ + "delet", + "e the " + ], + [ + "];\\n ", + "uint256 " + ], + [ + "signer", + " address" + ], + [ + "List", + "ed" + ], + [ + "their ", + "own " + ], + [ + "Can", + "'t " + ], + [ + "protocol", + "/" + ], + [ + "createPair", + "(address tokenA, address tokenB" + ], + [ + "standard ", + "message " + ], + [ + "AN", + "D" + ], + [ + "99", + "99" + ], + [ + "div(", + "sub(" + ], + [ + "ownedTokens", + "Index[tokenId" + ], + [ + "_startTokenId", + "() <= " + ], + [ + ";\\r\\n\\r\\n ", + "// " + ], + [ + "directly ", + "access" + ], + [ + "aph", + "son " + ], + [ + "seri", + "al" + ], + [ + "\\n ) external returns (", + "uint amountA, uint amountB" + ], + [ + "track", + " " + ], + [ + "eth_", + "usd" + ], + [ + "Revert ", + "with a " + ], + [ + "`.\\n *\\n * This ", + "function " + ], + [ + "#(", + "##" + ], + [ + "missing ", + "`role" + ], + [ + "in the set. O(1", + ").\\n *\\n * " + ], + [ + "Gas", + "Limit" + ], + [ + "acce", + "pt " + ], + [ + "returndata.length", + " > 0) {\\n // " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, ", + "deducting " + ], + [ + "[i", + "] = " + ], + [ + "-R", + "aphson " + ], + [ + " it", + "eration" + ], + [ + "ERC721A__", + "IERC721Receiver" + ], + [ + "(\\n address sender,\\n address recipient", + ",\\n uint256 " + ], + [ + "\\n }\\n }\\n }\\n ", + "} else {\\n return true" + ], + [ + "overridden ", + "in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return " + ], + [ + "could ", + "be " + ], + [ + "value stored at position `index` ", + "in the set. O(1).\\n *\\n * " + ], + [ + "bytes4 retval", + ") {\\n return " + ], + [ + "ential", + "Owner" + ], + [ + "total amount of tokens ", + "stored by the contract" + ], + [ + "Newton", + "-Raphson " + ], + [ + ") {\\n if (", + "reason.length == 0) {\\n " + ], + [ + "\\\");\\n\\n _", + "revokeRole(role, account);\\n }\\n\\n /**\\n * @dev " + ], + [ + "/**\\n\\t * ", + "@notice " + ], + [ + ", and", + "\\n // " + ], + [ + "\\n *\\n * Emits a {", + "Approval" + ], + [ + "} that allows ", + "token holders to " + ], + [ + "}.\\n *\\n * Requirements:\\n *\\n * - ", + "the caller must have allowance for " + ], + [ + "revert(add(32, reason), mload(reason))", + "\\n }\\n }\\n }\\n } else {\\n return true" + ], + [ + " /**\\n * @dev Returns the ", + "value stored at position `index` in the set. O(1).\\n *\\n * " + ], + [ + "1inch", + "/" + ], + [ + "operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * ", + "class of bugs, so it's recommended to use it alway" + ], + [ + "} and {ERC20-allowance", + "}.\\n *\\n * Requirements:\\n *\\n * - the caller must have allowance for " + ], + [ + "multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*", + "` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul" + ], + [ + "keccak256(abi.encodePacked(\\\"\\\\x19\\\\x01\\\", ", + "domainSeparator, " + ], + [ + "standardized way to retrieve royalty payment", + " information" + ], + [ + "to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(", + "!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n " + ], + [ + "assembly {\\n ", + "revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true" + ], + [ + "s `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId", + ") internal virtual {\\n require(" + ], + [ + ";\\n } catch (bytes memory reason", + ") {\\n if (reason.length == 0) {\\n " + ], + [ + "Revert with a ", + "standard message " + ], + [ + "bytes4 retval) {\\n return ", + "retval == " + ], + [ + " /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * ", + "Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function " + ], + [ + ";\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n ", + " " + ], + [ + "\"", + "W" + ], + [ + "\"", + "You " + ], + [ + "-", + "based " + ], + [ + ".", + "\\r\\n " + ], + [ + ".", + "github" + ], + [ + "0", + "Out" + ], + [ + "D", + "4" + ], + [ + "F", + "C" + ], + [ + "N", + "N" + ], + [ + "N", + "O" + ], + [ + "P", + "c" + ], + [ + "[", + "lastTokenId" + ], + [ + "_", + "basicTransfer" + ], + [ + "b", + "er of " + ], + [ + "d", + "C" + ], + [ + "e", + "12" + ], + [ + "f", + "7" + ], + [ + "g", + "ap" + ], + [ + "h", + "ed" + ], + [ + "i", + "ence " + ], + [ + "p", + "ast " + ], + [ + "u", + "ff" + ], + [ + "|", + " " + ], + [ + "\\n", + "@return " + ], + [ + "re", + "pay" + ], + [ + "s ", + "needed to " + ], + [ + "int", + "end" + ], + [ + ", ", + "false" + ], + [ + "it", + "al " + ], + [ + "pu", + "te" + ], + [ + ") {", + "\\r\\n " + ], + [ + "return ", + "data " + ], + [ + "index", + " of the token" + ], + [ + "set", + "BaseURI" + ], + [ + ";\\n ", + "}\\n }\\n}\\n\"" + ], + [ + "), ", + "lt(" + ], + [ + "msgSender", + " = _msgSender(" + ], + [ + "(uint256 ", + "quantity" + ], + [ + "current", + "Id" + ], + [ + "Approval", + "(owner, " + ], + [ + "cre", + "ated by " + ], + [ + "tokens ", + "array" + ], + [ + "Li", + "ve" + ], + [ + "allow", + "s the " + ], + [ + ".\\n */\\n function _", + "startTokenId" + ], + [ + "result ", + "overflow" + ], + [ + "``", + "accounts" + ], + [ + "\\r\\n * ", + "@return " + ], + [ + ")\\n ", + "returns (" + ], + [ + "string memory", + ") {\\n require(" + ], + [ + "beforeTokenTransfer", + "s" + ], + [ + "ess ", + "convention" + ], + [ + "chang", + "es" + ], + [ + "Reward", + "Amount" + ], + [ + ".\\n ", + "bool " + ], + [ + ";\\n }\\n\\n ", + "/**" + ], + [ + "s a ", + "uint256 or " + ], + [ + "last", + "TokenId = _" + ], + [ + "last ", + "token in the " + ], + [ + "last ", + "slot (" + ], + [ + "signature", + "s from " + ], + [ + "; // ", + "Move the " + ], + [ + "not", + "(0" + ], + [ + "not", + "Ente" + ], + [ + ") internal view returns (", + "uint64" + ], + [ + "55", + "6" + ], + [ + ".\\n ", + "struct " + ], + [ + "previous", + "Balance" + ], + [ + "then ", + "delete the " + ], + [ + " := ", + "byte(0, " + ], + [ + ") public virtual override ", + "returns (bool) {\\r\\n " + ], + [ + "chain", + "Id " + ], + [ + "Base", + "64" + ], + [ + "gu", + "ess" + ], + [ + "delet", + "es the " + ], + [ + "Col", + "lector" + ], + [ + "}\\r\\n", + "\\r\\n\\r\\n" + ], + [ + "_C", + "ON" + ], + [ + "_isExcludedFromFees", + "[from] " + ], + [ + "swapTokensFor", + "ETH" + ], + [ + "uint256[] memory ", + "amounts" + ], + [ + "(uint256 a, uint256 b) internal pure returns (", + "uint256) {\\r\\n return " + ], + [ + " to the ", + "slot of the " + ], + [ + ".\\n", + "\\n // " + ], + [ + "sour", + "ce" + ], + [ + "Cur", + "rency" + ], + [ + "div(", + "prod0, " + ], + [ + "liqui", + "d" + ], + [ + "call{", + "value: " + ], + [ + "IERC721Receiver-onERC721Received}, which is called ", + "for each " + ], + [ + "\\r\\n ", + "// " + ], + [ + "\\n if (", + "a " + ], + [ + ", we ", + "store the " + ], + [ + "do ", + "the " + ], + [ + "Slot ", + "{\\n " + ], + [ + "moved ", + "token" + ], + [ + "IV", + "IS" + ], + [ + "to-", + "delete token" + ], + [ + "Part", + "ID" + ], + [ + "512", + "-bit " + ], + [ + "development", + "Wallet" + ], + [ + "reserveIn", + ", uint reserveOut" + ], + [ + "tokenId uint256 ID of the token", + " to be " + ], + [ + "increase", + "Approval" + ], + [ + "returning `false` on failure. This behavior is nonethel", + "ess convention" + ], + [ + "and does not conflict with the expectations of ", + "ERC20 " + ], + [ + "Kee", + "ps " + ], + [ + "token to ", + "delete is the " + ], + [ + "denominator) ", + "with full precision" + ], + [ + "currOwnershipAddr", + " = " + ], + [ + "lpBurn", + "Enabled" + ], + [ + "lpBurn", + "Frequency" + ], + [ + "a g", + "ap" + ], + [ + ");\\n require(\\n ", + "_checkOnERC721Received" + ], + [ + "_ownerships[", + "nextTokenId" + ], + [ + "mload(add(signature, 0x", + "60" + ], + [ + "x * ", + "y" + ], + [ + "iteration", + " to " + ], + [ + "uniswapV2Router.", + "WETH" + ], + [ + ")\\n public\\n view\\n virtual\\n override", + "(" + ], + [ + "Resol", + "ution" + ], + [ + "given address", + "\\n */\\n function " + ], + [ + ".\\n *\\n * See {ERC20-_burn", + "} and {ERC20-allowance}.\\n *\\n * Requirements:\\n *\\n * - the caller must have allowance for " + ], + [ + "this.", + "update" + ], + [ + "last token", + ", the swap operation is unnecessary" + ], + [ + "last token", + " to the slot of the " + ], + [ + "decrease", + "Approval" + ], + [ + "denominator * inv = 1 ", + "mod " + ], + [ + "master", + "/contracts/" + ], + [ + "INTER", + "NAL" + ], + [ + "\\n\\t */", + "\\n\\tfunction " + ], + [ + "(\\r\\n address from,\\r\\n address to,\\r\\n uint256 ", + "amount\\r\\n " + ], + [ + "swap and pop", + ")." + ], + [ + "interact ", + "with " + ], + [ + "magnified", + "Dividend" + ], + [ + "When the ", + "token to delete is the " + ], + [ + "_burn(_msgSender(), amount", + ");\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, deducting " + ], + [ + "To prevent ", + "a gap" + ], + [ + "contents ", + "at the last " + ], + [ + "position of the ", + "array" + ], + [ + "address(0) && ownership.burned == false`)", + "\\n // " + ], + [ + "tokenIndex] = ", + "lastTokenId" + ], + [ + "Seconds.add(days30.", + "mul(" + ], + [ + "Extension of {ERC20", + "} that allows token holders to " + ], + [ + "This also ", + "deletes the " + ], + [ + "address signer = ecrecover", + "(hash, v, r, s" + ], + [ + "Pend", + "le" + ], + [ + "Emit an ", + "event " + ], + [ + "if (!_exists(tokenId)) revert URIQueryForNonexistentToken", + "();\\n\\n " + ], + [ + ". Throws if ", + "result overflow" + ], + [ + "Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId", + ") internal view virtual returns (bool) {\\n return " + ], + [ + "ownership-", + "tracking data structures" + ], + [ + "quad", + "rati" + ], + [ + "OpenZeppelin guidelines: functions revert ", + "instead" + ], + [ + "cogn", + "ized " + ], + [ + "] = tokenIndex", + "; // Update the " + ], + [ + "to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n ", + "_beforeTokenTransfer" + ], + [ + "assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true", + ";\\n }\\n }\\n\\n /**\\n * @dev " + ], + [ + "s `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(", + "to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer" + ], + [ + "index of the token", + " to delete" + ], + [ + "tokens array", + ", we store the " + ], + [ + "s a uint256 or ", + "denominator == 0" + ], + [ + "last token in the ", + "index of the token to delete" + ], + [ + "last slot (", + "swap and pop)." + ], + [ + "; // Move the ", + "last token to the slot of the " + ], + [ + "then delete the ", + "last slot (swap and pop)." + ], + [ + "IERC721Receiver-onERC721Received}, which is called for each ", + "safe transfer" + ], + [ + "denominator) with full precision", + ". Throws if result overflow" + ], + [ + "When the token to delete is the ", + "last token, the swap operation is unnecessary" + ], + [ + "contents at the last ", + "position of the array" + ], + [ + "This also deletes the ", + "contents at the last position of the array" + ], + [ + "] = tokenIndex; // Update the ", + "moved token" + ], + [ + "tokens array, we store the ", + "last token in the index of the token to delete" + ], + [ + "; // Move the last token to the slot of the ", + "to-delete token" + ], + [ + "denominator) with full precision. Throws if result overflow", + "s a uint256 or denominator == 0" + ], + [ + "\"", + "ECDSA: invalid signature " + ], + [ + "(", + "\\n _" + ], + [ + "1", + " = " + ], + [ + "1", + "Out" + ], + [ + "1", + ") {\\n " + ], + [ + "2", + "*" + ], + [ + "D", + "8" + ], + [ + "L", + "D" + ], + [ + "a", + "rn" + ], + [ + "s", + "old" + ], + [ + "v", + "ice " + ], + [ + "w", + "Squeeth" + ], + [ + "\\n ", + "{\\n require(" + ], + [ + "to", + "Uint256" + ], + [ + "ed", + "Amount" + ], + [ + "de", + "sp" + ], + [ + "de", + "tection" + ], + [ + "\\n ", + "require(" + ], + [ + "owner", + " = " + ], + [ + "sh", + "ow" + ], + [ + "pri", + "miti" + ], + [ + "(address ", + "newImplementation" + ], + [ + "wh", + "iteList" + ], + [ + "Amount", + "In" + ], + [ + "get", + "Reward" + ], + [ + ";\\n ", + "}\\n\\n // " + ], + [ + "s the ", + "order of the " + ], + [ + "private ", + "_" + ], + [ + "mint", + "Price" + ], + [ + ") external ", + "{\\n require(msg.sender == " + ], + [ + "only", + "Team" + ], + [ + ") public ", + "onlyOwner {\\r\\n " + ], + [ + "Ex", + "isting" + ], + [ + "token ", + "contract " + ], + [ + "token ", + "count" + ], + [ + "check", + "s" + ], + [ + "ot", + "e(" + ], + [ + "Mint", + "ers" + ], + [ + "'s ", + "lif" + ], + [ + "(\\n ", + "bytes32[] calldata proof" + ], + [ + ").", + "code.length" + ], + [ + "fo", + "o" + ], + [ + " ", + " " + ], + [ + "_A", + "MP" + ], + [ + ";\\n ", + "}\\n\\n // " + ], + [ + "amount ", + "+ " + ], + [ + "can be ", + "re" + ], + [ + "s to ", + "O(1) " + ], + [ + "Ch", + "in" + ], + [ + "transfer ", + "tokens " + ], + [ + "}.\\n */\\n function ", + "at(" + ], + [ + "prod", + "0." + ], + [ + "user", + "'s " + ], + [ + "dis", + "count" + ], + [ + "has ", + "O(1) time " + ], + [ + "ERC721A", + ".sol\"" + ], + [ + "Mo", + "st " + ], + [ + "pool", + "_" + ], + [ + "27", + ", " + ], + [ + "one ", + "of the " + ], + [ + "s for ", + "each " + ], + [ + "s = ", + "0;\\n " + ], + [ + "Typ", + "e." + ], + [ + ");\\n }\\n\\n /**\\n * @dev Returns the ", + "value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length" + ], + [ + ", but ", + "alter" + ], + [ + ") external;\\n\\n /**\\n * @dev ", + "Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool" + ], + [ + "v2", + "/contracts/" + ], + [ + "Balance = ", + "address(this).balance" + ], + [ + "tick", + "Upper" + ], + [ + "tick", + "Lower" + ], + [ + "value is ", + "a " + ], + [ + "Account", + "s" + ], + [ + "balanceOf(address account", + ") external view returns (uint256" + ], + [ + "ownedTokens", + "[from][" + ], + [ + "equal", + "s " + ], + [ + "LI", + "ST" + ], + [ + ". Th", + "at " + ], + [ + "/// @solidity memory-safe-assembly", + "\\n " + ], + [ + "tokens and ", + "those that " + ], + [ + "remove ", + "a token " + ], + [ + "Update", + "UniswapV2Router" + ], + [ + "Distribu", + "ted" + ], + [ + "move", + "s to O(1) " + ], + [ + "Overflow not ", + "possible" + ], + [ + "tokens of at least\\n * `amount`.\\n */\\n function ", + "burnFrom(address account, uint256 amount) public virtual " + ], + [ + "rate", + "Provider" + ], + [ + "math/Math", + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard " + ], + [ + "The address of the ", + "owner" + ], + [ + "RAT", + "E_" + ], + [ + "Mintable", + "By" + ], + [ + "/=lib/", + "forge-std" + ], + [ + "here ", + "starts off " + ], + [ + "A0", + "3" + ], + [ + "such that ", + "it is " + ], + [ + "spent ", + "here starts off " + ], + [ + "to == address(0)", + ") revert " + ], + [ + "Private function to ", + "add a " + ], + [ + "Private function to ", + "remove a token " + ], + [ + "uint256 result", + ") {\\n " + ], + [ + ", this ", + "is the " + ], + [ + "\\n * ", + "- `" + ], + [ + "256 bit ", + "number " + ], + [ + ") external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev ", + "Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved" + ], + [ + ") of ", + "supply" + ], + [ + "Make ", + "sure the " + ], + [ + "Reentrancy ", + "protection" + ], + [ + ";\\n uint256 ", + "end = " + ], + [ + "_allowances[sender][_msgSender()", + "].sub(amount, \\\"ERC20: transfer amount exceeds allowance\\\")" + ], + [ + "_approve(sender, _msgSender(), ", + "_allowances[sender][_msgSender()].sub(amount, \\\"ERC20: transfer amount exceeds allowance\\\")" + ], + [ + "doubl", + "ing the " + ], + [ + "Origin", + "al " + ], + [ + "roles[role].", + "adminRole" + ], + [ + ") public virtual {\\n ", + "_burn(_msgSender(), amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, deducting " + ], + [ + ") internal view returns (uint256) {\\n return _length(set._inner", + ");\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length" + ], + [ + "complexity", + ", but alter" + ], + [ + "TokenSupply", + "For" + ], + [ + "Rock", + "et" + ], + [ + "(\\n uint amountIn,\\n uint amountOutMin,\\n address[] calldata path,\\n address to,\\n uint deadline", + "\\n " + ], + [ + ")\\n private", + "\\n view\\n returns (" + ], + [ + ");\\n\\n _beforeTokenTransfer", + "(owner, address(0), tokenId" + ], + [ + "path[0] = ", + "address(this" + ], + [ + "destroy ", + "both " + ], + [ + "gradually ", + "moves to O(1) " + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../", + "IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\"" + ], + [ + "token/ERC721/IERC721Receiver.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ", + "ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721Receiver {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `" + ], + [ + ".\\n *\\n * See {ERC20-_burn}.\\n */\\n function burn(uint256 amount", + ") public virtual {\\n _burn(_msgSender(), amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, deducting " + ], + [ + "owner cannot ", + "have more than " + ], + [ + "[lastTokenId", + "] = tokenIndex; // Update the moved token" + ], + [ + "tokenIndex] = lastTokenId", + "; // Move the last token to the slot of the to-delete token" + ], + [ + "vice ", + "versa" + ], + [ + "s the order of the ", + "_" + ], + [ + "has O(1) time ", + "complexity, but alter" + ], + [ + "math/Math.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard ", + "math utilities missing in the Solidity language.\\n */\\nlibrary Math" + ], + [ + "Private function to add a ", + "token to " + ], + [ + "Private function to remove a token ", + "from " + ], + [ + ") external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved", + ") external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool" + ], + [ + ") internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length", + "}.\\n */\\n function at(" + ], + [ + "gradually moves to O(1) ", + "as tokens " + ], + [ + "has O(1) time complexity, but alter", + "s the order of the _" + ], + [ + "\"", + "T" + ], + [ + "\"", + "@openzeppelin/" + ], + [ + "'", + "v" + ], + [ + "(", + "and not " + ], + [ + "(", + "IERC20 " + ], + [ + ",", + "{\\\"" + ], + [ + ".", + "\\n * @dev " + ], + [ + "0", + "/" + ], + [ + "B", + "AA" + ], + [ + "K", + "E" + ], + [ + "L", + "ayer" + ], + [ + "O", + "b" + ], + [ + "P", + "HI" + ], + [ + "_", + "setApprovalForAll" + ], + [ + "_", + "revokeRole" + ], + [ + "_", + "creator" + ], + [ + "f", + ", r" + ], + [ + "m", + " to " + ], + [ + "v", + " != " + ], + [ + "v", + "`, `" + ], + [ + "\\n", + "library " + ], + [ + "al", + "gorithm" + ], + [ + "\\n *", + "\\n * - `" + ], + [ + "uint", + "(" + ], + [ + ", ", + "only " + ], + [ + ", ", + "tokenB" + ], + [ + "function", + ". " + ], + [ + "es", + "ting " + ], + [ + ") ", + "ratio" + ], + [ + "all", + "Tokens array" + ], + [ + "co", + " B" + ], + [ + "em", + "en " + ], + [ + "ic", + "i" + ], + [ + "= ", + "`" + ], + [ + "amount", + " of the " + ], + [ + "se", + "a" + ], + [ + "address ", + "constant " + ], + [ + "address ", + "msgSender = _msgSender(" + ], + [ + "To", + "Transfer" + ], + [ + "ma", + "y" + ], + [ + "require", + " (" + ], + [ + "Tr", + "ait" + ], + [ + "lo", + "emen " + ], + [ + " = ", + "tokenId" + ], + [ + "--", + "2-" + ], + [ + "(address ", + "_from" + ], + [ + "for ", + "v" + ], + [ + "ERC721", + "Creator" + ], + [ + "get", + "Total" + ], + [ + "pro", + "venanceHash" + ], + [ + "sender", + "Balance = " + ], + [ + "only", + "Pauser" + ], + [ + "ke", + "y, " + ], + [ + "token ", + "tracking data structures" + ], + [ + "tar", + "t " + ], + [ + "pa", + "per " + ], + [ + "when ", + "token was burned" + ], + [ + "for", + ", in a " + ], + [ + "event ", + "analysis" + ], + [ + "au", + "tion" + ], + [ + "buy", + "TreasuryFee" + ], + [ + "hash", + "es" + ], + [ + "` cannot be ", + "greater than " + ], + [ + "sell", + " " + ], + [ + "typ", + "es" + ], + [ + "\\\\", + "____" + ], + [ + "there", + "fo" + ], + [ + "__", + "gap" + ], + [ + ".sol)", + "\\r\\n\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\n" + ], + [ + ");\\r\\n", + "}\\r\\n\\r\\n" + ], + [ + "signed ", + "approval" + ], + [ + "proof", + "[i]" + ], + [ + "approve ", + "from " + ], + [ + " `", + "value" + ], + [ + "fe", + "e is " + ], + [ + "get ", + "transferred " + ], + [ + "then ", + "it " + ], + [ + "We ", + "will " + ], + [ + "nonReentrant", + "Before" + ], + [ + "nonReentrant", + "After" + ], + [ + "way ", + "that can " + ], + [ + "if (!", + "_checkContractOnERC721Received" + ], + [ + ", bytes32 ", + "leaf" + ], + [ + "Rem", + "co B" + ], + [ + ")\\n {\\n ", + "// " + ], + [ + "automatedMarketMakerPair", + "s\"" + ], + [ + "return true", + ";\\n }\\n\\n function " + ], + [ + "royalty", + "Fraction" + ], + [ + "_F", + "OR" + ], + [ + "28", + "4" + ], + [ + "28", + ", " + ], + [ + "author", + "iz" + ], + [ + "` must be ", + "a valid " + ], + [ + "custom", + "Revert" + ], + [ + "curr", + " = tokenId" + ], + [ + "quantity ", + "- the amount to be transferred" + ], + [ + "v2", + "." + ], + [ + "UN", + "LICENS" + ], + [ + "cove", + "red " + ], + [ + "ptr", + " := add(" + ], + [ + "\\\");\\n _", + "safeTransfer" + ], + [ + "track", + " the " + ], + [ + "bits ", + "of the " + ], + [ + "srcRep", + "New" + ], + [ + "Author", + "ization" + ], + [ + "most ", + "significant" + ], + [ + "computedHash", + ", " + ], + [ + "startTokenId ", + "- the first " + ], + [ + "an allowance ", + "for, in a " + ], + [ + "onlyRole(", + "DEFAULT_ADMIN_ROLE" + ], + [ + "Auto", + "NukeLP" + ], + [ + "_initializ", + "ing " + ], + [ + "See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual ", + "override(" + ], + [ + ";\\n ", + "if (" + ], + [ + "66", + "7" + ], + [ + "token id ", + "to be transferred" + ], + [ + "\\\"\\\"", + ";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n " + ], + [ + "Gas ", + "spent here starts off " + ], + [ + "format", + "ted " + ], + [ + "afterTokenTransfers", + "(\\n address from,\\n address to,\\n uint256 startTokenId,\\n uint256 quantity\\n " + ], + [ + "Vi", + "rtual" + ], + [ + ") return (false, 0);\\n return (true, ", + "c" + ], + [ + "\\n * @param tokenId uint256 ID of the token", + " to be " + ], + [ + "global ", + "default" + ], + [ + "rend", + "er" + ], + [ + "off-chain ", + "(via " + ], + [ + "migr", + "ation" + ], + [ + "; ++i", + ") {\\n " + ], + [ + "```\\n * ", + "contract " + ], + [ + "if (b == 0", + ") return (false, 0);\\n return (true, " + ], + [ + "(\\n address from,\\n address to,\\n uint256 startTokenId,\\n uint256 quantity\\n ", + ") internal virtual {}\\n\\n /**\\n * @dev Hook that is called after " + ], + [ + "`to`.", + "\\r\\n * - " + ], + [ + "token ids ", + "via {" + ], + [ + "including the ", + "Enumerable extension" + ], + [ + "emit OwnershipTransferred(_owner", + ", address(0)" + ], + [ + "_00", + "_00" + ], + [ + "convert", + "To" + ], + [ + "r := shr(", + "f, r" + ], + [ + "the fee ", + "denominator" + ], + [ + "(data);\\n return _verifyCallResult(success, returndata, errorMessage", + ");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes" + ], + [ + "ERC2981: ", + "royalty fee " + ], + [ + "pair cannot be removed from ", + "automatedMarketMakerPairs\"" + ], + [ + "absTick", + " & 0x" + ], + [ + "xn", + "--2-" + ], + [ + "Now ", + "that " + ], + [ + "), \\\"ERC721: transfer to non ERC721Receiver implementer", + "\\\");\\n }\\n\\n /**\\n * @dev " + ], + [ + "therwis", + "e" + ], + [ + "they have ", + "an allowance for, in a " + ], + [ + "proportional to the ", + "maximum mint" + ], + [ + ".swapExactTokensFor", + "ETHSupportingFeeOnTransferTokens" + ], + [ + "Ampl", + "ification" + ], + [ + ");\\n return (spender", + " == owner || " + ], + [ + ") {\\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691", + "\\n return " + ], + [ + ", but not ", + "including the Enumerable extension" + ], + [ + "start of ", + "ownership" + ], + [ + "will exceed ", + "salePrice" + ], + [ + "lower gas during batch mint", + "s.\\n *\\n * " + ], + [ + "umb", + ".com/" + ], + [ + "tokens list of the ", + "given address\\n */\\n function " + ], + [ + "keccak256(abi.encodePacked(\\\"\\\\x19\\\\x01\\\", domainSeparator, ", + "structHash" + ], + [ + "beforeTokenTransfers", + "(\\n address from,\\n address to,\\n uint256 startTokenId,\\n uint256 quantity\\n ) internal virtual {}\\n\\n /**\\n * @dev Hook that is called after " + ], + [ + " := byte(0, ", + "mload(add(signature, 0x60" + ], + [ + "cognized ", + "off-chain (via " + ], + [ + "Chin", + "ese " + ], + [ + "tokens and those that ", + "they have an allowance for, in a " + ], + [ + "destroy both ", + "their own" + ], + [ + "gradually moves to O(1) as tokens ", + "get transferred " + ], + [ + "Layer", + "Zero " + ], + [ + "` cannot be greater than ", + "the fee denominator" + ], + [ + "Remco B", + "loemen " + ], + [ + "most significant", + " bit" + ], + [ + "startTokenId - the first ", + "token id to be transferred" + ], + [ + "Gas spent here starts off ", + "proportional to the maximum mint" + ], + [ + "ERC2981: royalty fee ", + "will exceed salePrice" + ], + [ + "xn--2-", + "umb.com/" + ], + [ + "cognized off-chain (via ", + "event analysis" + ], + [ + "tokens and those that they have an allowance for, in a ", + "way that can " + ], + [ + "gradually moves to O(1) as tokens get transferred ", + "around " + ], + [ + "Gas spent here starts off proportional to the maximum mint", + " batch size" + ], + [ + "\"", + "operator-filter-registry/src/" + ], + [ + "(", + "address," + ], + [ + ".", + "increment" + ], + [ + "/", + "mul" + ], + [ + "2", + "._\\n */\\n function " + ], + [ + "6", + "AF" + ], + [ + "7", + " iteration" + ], + [ + "8", + "e" + ], + [ + "B", + "O" + ], + [ + "D", + "O" + ], + [ + "D", + "aily" + ], + [ + "H", + "ence" + ], + [ + "I", + "JB" + ], + [ + "L", + "aunch" + ], + [ + "O", + "FT" + ], + [ + "_", + "PO" + ], + [ + "c", + "losed" + ], + [ + "v", + "ol" + ], + [ + ", ", + "doubling the " + ], + [ + ") ", + "revert(" + ], + [ + "tr", + "ade" + ], + [ + "ing", + "\\r\\n * " + ], + [ + "= ", + "IUniswapV2Router02" + ], + [ + "is ", + "no longer " + ], + [ + "` ", + "event" + ], + [ + "` ", + "as " + ], + [ + "as", + "signed " + ], + [ + "\\n function ", + "mint" + ], + [ + ": ", + "cannot " + ], + [ + "dat", + "a s" + ], + [ + "ma", + ", this " + ], + [ + "Re", + "vShare" + ], + [ + "op", + "en " + ], + [ + " = ", + "128" + ], + [ + "spender", + " " + ], + [ + "in ", + "each step" + ], + [ + "not ", + "yet " + ], + [ + "In", + "vert " + ], + [ + "and ", + "prod1" + ], + [ + ";\\n ", + "} catch (bytes memory reason" + ], + [ + " to ", + "add" + ], + [ + "from ", + "prod1 " + ], + [ + "from ", + "[prod1 prod0" + ], + [ + "from ", + "512 bit " + ], + [ + "by ", + "starting " + ], + [ + "address(", + "uint160" + ], + [ + ", uint256 ", + "royaltyAmount" + ], + [ + "This ", + "contract " + ], + [ + "burn", + "ing one " + ], + [ + "address(0", + ");\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId" + ], + [ + "ting ", + "lem" + ], + [ + "\\n // ", + "this " + ], + [ + "action", + "Id" + ], + [ + "result ", + "and prod1" + ], + [ + "` is ", + "not " + ], + [ + "Set", + "s `" + ], + [ + "sell", + "TreasuryFee" + ], + [ + "0, ", + "twos), " + ], + [ + "s to ", + "Hen" + ], + [ + "ast ", + "significant 256 bits of the product" + ], + [ + ".\\n * - `", + "quantity` must be greater than 0" + ], + [ + "dition", + "s " + ], + [ + "Burn", + "ed(" + ], + [ + "`tokenId` ", + "has be" + ], + [ + "using ", + "mulmod" + ], + [ + "our", + "ce" + ], + [ + "sel", + "'s lif" + ], + [ + "result", + ". The result is " + ], + [ + ");\\n ", + "if (" + ], + [ + "number", + ", it " + ], + [ + "number", + "Burned " + ], + [ + "_balances[", + "msg.sender" + ], + [ + "(from, ", + "address(0), " + ], + [ + "denominator", + " := div(" + ], + [ + "denominator", + " is an " + ], + [ + "non-", + "overflow " + ], + [ + "Con", + "d" + ], + [ + "marketing", + "Address" + ], + [ + "zero, ", + "then it " + ], + [ + "(\\n address from", + ",\\n address to,\\n " + ], + [ + "ed in ", + "basis point" + ], + [ + "two ", + "256" + ], + [ + "two ", + "divisor " + ], + [ + "two ", + "out of " + ], + [ + "one ", + "token has been burned" + ], + [ + "implementation", + " of the " + ], + [ + "; // ", + "Le" + ], + [ + "; // ", + "Most " + ], + [ + "valid ", + "range " + ], + [ + "`owner", + "`\\n * " + ], + [ + "()", + ". " + ], + [ + ") {\\n require(", + "!" + ], + [ + "sub(", + "mm, prod0" + ], + [ + " bits", + ". That " + ], + [ + "minted ", + "in the contract" + ], + [ + "gu", + "y" + ], + [ + "claim", + "er" + ], + [ + "uint64", + ") of supply" + ], + [ + "\\n ) external ", + "virtual " + ], + [ + "also ", + "work" + ], + [ + "with the ", + "modular " + ], + [ + "result = ", + "prod0" + ], + [ + "number of tokens ", + "burned" + ], + [ + "_C", + "OR" + ], + [ + "AC", + "T" + ], + [ + "ect ", + "square" + ], + [ + "let ", + "mm" + ], + [ + "inverse ", + "of denominator" + ], + [ + "inverse ", + "by starting " + ], + [ + "available ", + "separately " + ], + [ + "division ", + "exact " + ], + [ + "division ", + "is now " + ], + [ + "before ", + "burning one " + ], + [ + "_ ", + "\\\\" + ], + [ + "after ", + "one token has been burned" + ], + [ + "Cre", + "ate" + ], + [ + "ve the ", + "precision" + ], + [ + ".\\r\\n *\\r\\n * ", + "Emits a {Transfer} event" + ], + [ + "Sh", + "utdown" + ], + [ + "largest ", + "power of " + ], + [ + "Balance = ", + "balanceOf(address(this)" + ], + [ + "checkpoint", + " " + ], + [ + "prod0", + "; // Le" + ], + [ + "start ", + "time of " + ], + [ + "way", + "s >= " + ], + [ + ", as ", + "_burnCounter cannot be " + ], + [ + "librari", + "es " + ], + [ + "prod1", + ", gt(" + ], + [ + "prod1", + "; // Most " + ], + [ + ")) {\\n ", + " " + ], + [ + ");\\n ", + "}\\n }\\n " + ], + [ + "Tar", + "get " + ], + [ + "Copy", + "right " + ], + [ + "bits ", + "in each step" + ], + [ + "bits ", + "from prod1 " + ], + [ + "FE", + "E_D" + ], + [ + "two", + "s = " + ], + [ + "two", + "s is " + ], + [ + "));\\n ", + "bytes32 " + ], + [ + "with a ", + "seed " + ], + [ + "ERC721Enumerable", + "}." + ], + [ + "exceed ", + "_currentIndex " + ], + [ + "ank", + "s to Hen" + ], + [ + "correct ", + "result " + ], + [ + "correct ", + "bits in each step" + ], + [ + "it to ", + "Remco Bloemen " + ], + [ + ", which is ", + "available separately " + ], + [ + "s {\\n ", + "struct " + ], + [ + "arithmetic", + ", doubling the " + ], + [ + "prod0 ", + ":= sub(" + ], + [ + "prod0 ", + "|= " + ], + [ + ";\\n emit Approval(owner, ", + "to, tokenId" + ], + [ + "pass", + "ed " + ], + [ + "512", + " by " + ], + [ + "remainder", + ", prod0" + ], + [ + "a0", + "8" + ], + [ + ", please ", + "override this function" + ], + [ + "argument", + "s." + ], + [ + "^ ", + "2" + ], + [ + ":= add(", + "div(sub(" + ], + [ + "remainder ", + ":= " + ], + [ + "remainder ", + "from [prod1 prod0" + ], + [ + "remainder ", + "using mulmod" + ], + [ + "21", + "/mul" + ], + [ + "if (b", + " > a" + ], + [ + "Price ", + "* " + ], + [ + "_burnCounter", + "++" + ], + [ + "such that ", + "product = " + ], + [ + "exact ", + "we can " + ], + [ + "use the ", + "Chinese " + ], + [ + "Calculates ", + "floor" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9", + ".0) (utils/" + ], + [ + "high ", + "bits of the " + ], + [ + "denominator) ", + "^ 2" + ], + [ + "xC", + "VX" + ], + [ + "[prod1 prod0", + "] " + ], + [ + "[prod1 prod0", + "] = " + ], + [ + ") {\\n if (", + "reason.length" + ], + [ + "PRIC", + "E" + ], + [ + "final ", + "result" + ], + [ + "s `quantity` tokens and transfers them to `to", + "`.\\n *\\n * Requirements:\\n *\\n * - " + ], + [ + "There ", + "will always " + ], + [ + " been granted `role`, emits a {RoleRevoked", + "}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account" + ], + [ + "\\x", + "01" + ], + [ + "compute the ", + "high bits of the " + ], + [ + "2098", + " " + ], + [ + ").\\r\\n *\\r\\n * ", + "Counterpart to Solidity's `" + ], + [ + "variables ", + "such that product = " + ], + [ + "Divide ", + "denominator " + ], + [ + "Divide ", + "[prod1 prod0] " + ], + [ + "Make ", + "division exact " + ], + [ + "total amount of tokens ", + "minted in the contract" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Safely mint", + "s `quantity` tokens and transfers them to `to`.\\n *\\n * Requirements:\\n *\\n * - " + ], + [ + "prod0, ", + "remainder" + ], + [ + " - 1 (max value of ", + "uint64) of supply" + ], + [ + "prod1 * ", + "twos" + ], + [ + "prod1 := sub(", + "sub(mm, prod0" + ], + [ + "prod1 := sub(", + "prod1, gt(" + ], + [ + "prod0 := ", + "div(prod0, " + ], + [ + "512 bit ", + "result. The result is " + ], + [ + "_burnCounter cannot be ", + "increment" + ], + [ + "CANONICAL", + "_OPERATOR_FILTER_REGISTRY" + ], + [ + "twos ", + ":= add(div(sub(" + ], + [ + "under MIT licen", + "se " + ], + [ + "Lin", + "ear" + ], + [ + "t in ", + "bits from prod1 " + ], + [ + "multiply ", + "[prod1 prod0] = " + ], + [ + "2**64", + " - 1 (max value of uint64) of supply" + ], + [ + "allowedNft", + "Token" + ], + [ + ".startTimestamp = uint64(", + "block.timestamp" + ], + [ + "tokens list", + "\\n */\\n function " + ], + [ + "impro", + "ve the precision" + ], + [ + "Whether the ", + "token has been burned" + ], + [ + "perf", + "ect square" + ], + [ + "];\\n\\n // ", + "When the token to delete is the last token, the swap operation is unnecessary" + ], + [ + "\\n\\n uint256 ", + "lastTokenIndex" + ], + [ + "is, ", + "denominator * inv = 1 mod " + ], + [ + "don't need to ", + "compute the high bits of the " + ], + [ + "stored in ", + "two 256" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {", + "\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\"" + ], + [ + "Compute ", + "remainder using mulmod" + ], + [ + "computedHash = ", + "leaf" + ], + [ + "3 * ", + "denominator) ^ 2" + ], + [ + "try IERC721Receiver(to).onERC721Received(_msgSender(), ", + "from, tokenId, _data) returns (" + ], + [ + "By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200)\\n _status = _NOT_ENTERED", + ";\\n }\\n}\\n\"" + ], + [ + "on SeaDrop", + ".\\n * Only " + ], + [ + "Subtract ", + "256 bit number " + ], + [ + "powers of ", + "two out of " + ], + [ + "Remainder ", + "Theore" + ], + [ + "Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the\\n * zero ", + "address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId" + ], + [ + "cases, ", + "256 by " + ], + [ + "(account, address(0), amount);\\n\\n _afterTokenTransfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(\\n address owner,\\n address spender,\\n uint256 amount\\n ) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Updates `owner` s allowance for `spender` based on spent `amount`.\\n *\\n * Does not update the allowance amount in case of infinite allowance.\\n * Revert if not enough allowance is available.\\n *\\n * Might emit an {Approval} event.\\n */\\n function _spendAllowance", + "(\\n address owner,\\n address spender,\\n uint256 amount\\n ) internal virtual {\\n uint256 currentAllowance = allowance(owner, spender);\\n if (currentAllowance != type(uint256).max) {\\n require(currentAllowance >= amount, \\\"ERC20: insufficient allowance\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - amount);\\n }\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {}\\n\\n /**\\n * @dev Hook that is called after any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * has been transferred to `to`.\\n * - when `from` is zero, `amount` tokens have been minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {}\\n}\\n\"" + ], + [ + ") internal virtual {\\n _transfer(from, to, tokenId", + ");\\n require(_checkOnERC721Received" + ], + [ + "four", + " bits. That " + ], + [ + "Norm", + "al" + ], + [ + "Factor ", + "powers of two out of " + ], + [ + "Handle ", + "non-overflow " + ], + [ + "odd ", + "number, it " + ], + [ + "by subtracting the ", + "remainder from [prod1 prod0" + ], + [ + "Because the ", + "division is now " + ], + [ + "OwnershipTransferred(address(0), ", + "msgSender" + ], + [ + "Newton-Raphson ", + "iteration to " + ], + [ + ", and\\n // ", + "then delete the last slot (swap and pop)." + ], + [ + "), lt(", + "mm, prod0" + ], + [ + "512-bit ", + "multiply [prod1 prod0] = " + ], + [ + "Extension of {ERC20} that allows token holders to ", + "destroy both their own" + ], + [ + "quadrati", + "cally " + ], + [ + "IERC721Receiver-onERC721Received}, which is called for each safe transfer", + ".\\n * - `quantity` must be greater than 0" + ], + [ + "tokens array, we store the last token in the index of the token to delete", + ", and\\n // then delete the last slot (swap and pop)." + ], + [ + "Overflow not possible", + ", as _burnCounter cannot be " + ], + [ + ", this is the ", + "final result" + ], + [ + "Make sure the ", + "result is " + ], + [ + "owner cannot have more than ", + "2**64 - 1 (max value of uint64) of supply" + ], + [ + "senderBalance = ", + "_balances[sender" + ], + [ + "UNLICENS", + "ED" + ], + [ + "Now that ", + "denominator is an " + ], + [ + ", but not including the Enumerable extension", + ", which is available separately " + ], + [ + "xn--2-umb.com/", + "21/mul" + ], + [ + "cognized off-chain (via event analysis", + ")." + ], + [ + "is no longer ", + "required" + ], + [ + "ma, this ", + "also work" + ], + [ + "Invert ", + "denominator " + ], + [ + ";\\n } catch (bytes memory reason", + ") {\\n if (reason.length" + ], + [ + "from 512 bit ", + "number" + ], + [ + "ting lem", + "ma, this also work" + ], + [ + "0, twos), ", + "twos), " + ], + [ + "sel's lif", + "ting lemma, this also work" + ], + [ + "numberBurned ", + "+= 1" + ], + [ + "denominator := div(", + "denominator, " + ], + [ + "zero, then it ", + "becomes " + ], + [ + "two divisor ", + "of denominator" + ], + [ + "with the modular ", + "inverse of denominator" + ], + [ + "result = prod0", + " * " + ], + [ + "let mm", + " := " + ], + [ + "inverse by starting ", + "with a seed " + ], + [ + "before burning one ", + "token" + ], + [ + "largest power of ", + "two divisor of denominator" + ], + [ + "prod0; // Le", + "ast significant 256 bits of the product" + ], + [ + "start time of ", + "ownership " + ], + [ + "prod1; // Most ", + "significant 256 bits of the product" + ], + [ + "twos is ", + "zero, then it becomes " + ], + [ + "anks to Hen", + "sel's lifting lemma, this also work" + ], + [ + "it to Remco Bloemen ", + "under MIT license " + ], + [ + "arithmetic, doubling the ", + "correct bits in each step" + ], + [ + "prod0 := sub(", + "prod0, remainder" + ], + [ + "prod0 |= ", + "prod1 * twos" + ], + [ + "512 by ", + "256 division" + ], + [ + "exact we can ", + "divide by " + ], + [ + "use the Chinese ", + "Remainder Theore" + ], + [ + "There will always ", + "be an " + ], + [ + "variables such that product = ", + "prod1 * " + ], + [ + "Make division exact ", + "by subtracting the remainder from [prod1 prod0" + ], + [ + "prod1 := sub(sub(mm, prod0", + "), lt(mm, prod0" + ], + [ + "prod1 := sub(prod1, gt(", + "remainder, prod0" + ], + [ + "512 bit result. The result is ", + "stored in two 256" + ], + [ + "CANONICAL_OPERATOR_FILTER_REGISTRY", + "_ADDRESS" + ], + [ + "twos := add(div(sub(", + "0, twos), twos), " + ], + [ + "t in bits from prod1 ", + "into " + ], + [ + "perfect square", + ", the " + ], + [ + "don't need to compute the high bits of the ", + "result and prod1" + ], + [ + "Subtract 256 bit number ", + "from 512 bit number" + ], + [ + "cases, 256 by ", + "256 division" + ], + [ + "four bits. That ", + "is, denominator * inv = 1 mod " + ], + [ + "Factor powers of two out of ", + "denominator" + ], + [ + "Handle non-overflow ", + "cases, 256 by 256 division" + ], + [ + "odd number, it ", + "has an " + ], + [ + "Because the division is now ", + "exact we can divide by " + ], + [ + "Newton-Raphson iteration to ", + "improve the precision" + ], + [ + "tokens array, we store the last token in the index of the token to delete, and\\n // then delete the last slot (swap and pop).", + "\\n\\n uint256 lastTokenIndex" + ], + [ + "Overflow not possible, as _burnCounter cannot be ", + "exceed _currentIndex " + ], + [ + "Now that denominator is an ", + "odd number, it has an " + ], + [ + ", but not including the Enumerable extension, which is available separately ", + "as" + ], + [ + "xn--2-umb.com/21/mul", + "div" + ], + [ + ";\\n } catch (bytes memory reason) {\\n if (reason.length", + " == 0) {\\n " + ], + [ + "inverse by starting with a seed ", + "that is " + ], + [ + "use the Chinese Remainder Theore", + "m to " + ], + [ + "#", + "specification" + ], + [ + "&", + "@" + ], + [ + "-", + "re" + ], + [ + ".", + "\\n * @return " + ], + [ + "/", + "#" + ], + [ + "2", + "27" + ], + [ + "2", + "bb" + ], + [ + "C", + "D0" + ], + [ + "E", + "ye" + ], + [ + "K", + "ar" + ], + [ + "N", + "et" + ], + [ + "P", + "enal" + ], + [ + "S", + "PDX-License-Identifier: " + ], + [ + "Y", + "el" + ], + [ + "[", + "_msgSender()" + ], + [ + "[", + "address(this)" + ], + [ + "_", + "partition" + ], + [ + "b", + "onus" + ], + [ + "b", + "oughtEarly" + ], + [ + "f", + "6" + ], + [ + "k", + "i" + ], + [ + "l", + "ect " + ], + [ + "p", + "red" + ], + [ + "q", + "/" + ], + [ + "s", + "on" + ], + [ + "v", + " from " + ], + [ + "al", + "ici" + ], + [ + "s ", + "will be " + ], + [ + "en", + "code " + ], + [ + "to", + "\\n // the " + ], + [ + ", ", + "a" + ], + [ + "ac", + "on " + ], + [ + "uint256", + ". " + ], + [ + "**", + "/" + ], + [ + "// ", + "only " + ], + [ + "Id", + "(" + ], + [ + "or ", + "on behalf of `owner" + ], + [ + "ERC20", + "(" + ], + [ + "\\n * ", + "roles" + ], + [ + "tokenId", + "_" + ], + [ + "sh", + "are " + ], + [ + "for ", + "s in " + ], + [ + "32", + "10" + ], + [ + "get", + "Current" + ], + [ + "Return", + " " + ], + [ + "require(", + "hasRole(" + ], + [ + "Of", + "(address addr) external returns (" + ], + [ + "s.", + "\\n " + ], + [ + "onlyOwner", + "Or" + ], + [ + "are ", + "not " + ], + [ + "this ", + "possibility " + ], + [ + "swap", + "Tokens" + ], + [ + "pay", + "e" + ], + [ + "\\\");\\n ", + "if (" + ], + [ + "safe", + "96" + ], + [ + "(\\n address ", + "seaDropImpl" + ], + [ + ";\\n ", + "address private " + ], + [ + ";\\n ", + "bool private " + ], + [ + "buy", + "Count" + ], + [ + "revert ", + "OwnerQueryForNonexistentToken" + ], + [ + "Pro", + "of " + ], + [ + "data ", + "= " + ], + [ + "rol", + "es, " + ], + [ + "\\n /// ", + "@notice " + ], + [ + " > ", + "prod1" + ], + [ + "AL", + "_EXPONENT" + ], + [ + ";\\r\\n", + "\\t" + ], + [ + "(tokenId", + ");\\n } else if (" + ], + [ + ");\\n }\\n\\n ", + "/**\\n * Returns the " + ], + [ + "Num", + "ber of " + ], + [ + "Rate", + "Cache" + ], + [ + "Po", + "st" + ], + [ + "gener", + "ate a " + ], + [ + "fin", + "d " + ], + [ + "receiver", + "` cannot be the zero address.\\n * - `" + ], + [ + "string,", + "uint" + ], + [ + "without ", + "the " + ], + [ + "chain", + "link" + ], + [ + ", uint ", + "reserveIn, uint reserveOut" + ], + [ + "does not ", + "decrement" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.", + "4.0 (" + ], + [ + "_N", + "ATUR" + ], + [ + "tokenA", + ", tokenB" + ], + [ + "A ", + "helper " + ], + [ + "_currentIndex", + " = _startTokenId" + ], + [ + ",\\n bytes32 ", + "leaf" + ], + [ + "being ", + "emitted " + ], + [ + "excluded", + "From" + ], + [ + "s.length", + "; i++) {\\n " + ], + [ + ";\\n\\t", + "\\t" + ], + [ + "edition", + "Size" + ], + [ + "Votes", + "(address account" + ], + [ + "delete ", + "_owners[tokenId" + ], + [ + "Exceed", + "s " + ], + [ + "flag", + " " + ], + [ + "Fl", + "ip " + ], + [ + "shares", + "_" + ], + [ + ".\\n * @param ", + "tokenId uint256 ID of the token to be " + ], + [ + "any", + "\\n * " + ], + [ + "overrid", + "ing the " + ], + [ + "Invariant", + ":" + ], + [ + ";\\n // ", + "Keeps " + ], + [ + "multiple ", + "times" + ], + [ + "Returns an ", + "Ethereum Signed " + ], + [ + "[msg.sender", + "] " + ], + [ + "\"ERC721: ", + "transfer to non ERC721Receiver implementer\"" + ], + [ + "ln", + "(a" + ], + [ + "1)", + ": " + ], + [ + "minting", + "Finished" + ], + [ + "first", + "Block" + ], + [ + "`account`.\\n *\\n * ", + "Internal function without access restriction" + ], + [ + "//\\n//", + " " + ], + [ + "2**256", + " - 1 (max value of " + ], + [ + ";\\n uint256 private ", + "immutable _" + ], + [ + "sequ", + "ently" + ], + [ + "Not ", + "enough " + ], + [ + "];\\n }\\n\\n /**\\n * @dev See {IERC721-", + "ownerOf}.\\n */\\n function ownerOf" + ], + [ + "a == ", + "0 ? 0 : " + ], + [ + "burned by ", + "or on behalf of `owner" + ], + [ + ").\\n */\\n function _", + "get" + ], + [ + "additionalPayee", + "SecondarySales" + ], + [ + "spl", + "it " + ], + [ + "security/ReentrancyGuard", + ".sol\"" + ], + [ + "),\\n \\\"", + "ERC721: transfer to non ERC721Receiver implementer" + ], + [ + "E_P", + "RECISION" + ], + [ + "_burnCounter ", + "- " + ], + [ + "enforc", + "ed by the " + ], + [ + "s `quantity` tokens and transfers them to `to", + "`" + ], + [ + "name, ", + "_symbol" + ], + [ + "onlyAllowedOperatorApproval", + "(operator" + ], + [ + "and it is ", + "initialized to " + ], + [ + "_balances[owner", + "];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf" + ], + [ + ") public view virtual override returns (uint256) {\\n require(", + "owner != address(0), \\\"ERC721: " + ], + [ + "secp256k1", + "` " + ], + [ + "secp256k1", + "n " + ], + [ + "paper", + "/" + ], + [ + "_operations", + "Fee" + ], + [ + "senderBalance ", + "- amount" + ], + [ + "Aux(address owner", + ", uint64 " + ], + [ + "Aux(address owner", + ") internal view returns (uint64" + ], + [ + ";\\n\\n // Mapping owner address to ", + "token count" + ], + [ + "this extension's ", + "ownership-tracking data structures" + ], + [ + "(_from, ", + "_to, " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId", + ") internal virtual {\\n " + ], + [ + "UniswapV2Library.", + "pairFor" + ], + [ + ",\\n bytes32 root", + ",\\n bytes32 leaf" + ], + [ + "() internal view virtual returns (uint256) {\\n return ", + "0" + ], + [ + "v3", + "-" + ], + [ + "cannot exceed ", + "2**256 - 1 (max value of " + ], + [ + "set._inner, bytes32(uint256(uint160(value))", + "));\\n }\\n\\n /**\\n * @dev " + ], + [ + "For more ", + "information " + ], + [ + "making it ", + "call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant(" + ], + [ + "ROY", + "AL" + ], + [ + "_PRO", + "JEC" + ], + [ + "`.\\n *\\n * Requirements:\\n *\\n * - `", + "tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\\n */\\n function toHexString(address addr) internal pure returns (string memory) {\\n return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH", + ");\\n }\\n}\\n\"" + ], + [ + "messaging ", + "library " + ], + [ + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n uint256 c = a + b;\\n require(", + "c >= a, \\\"SafeMath: addition overflow" + ], + [ + "_msgSender() == owner || isApprovedForAll(owner, _msgSender())", + ",\\n \\\"ERC721: " + ], + [ + "\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved", + "(uint256 tokenId) public view virtual override returns (address" + ], + [ + " 2", + " + 1" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to", + "`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients" + ], + [ + "VERY IMPORTANT: UNCOMMENT THIS LATER\\n // ", + "VERY IMPORTANT: UNCOMMENT THIS LATER\\n // " + ], + [ + "scr", + "atch " + ], + [ + ".github", + ".io/" + ], + [ + "``accounts", + "``'s " + ], + [ + "'v", + "' value" + ], + [ + "valid range ", + "for s in " + ], + [ + "ways >= ", + "1" + ], + [ + "Yel", + "low " + ], + [ + "_NATUR", + "AL_EXPONENT" + ], + [ + "),\\n \\\"ERC721: transfer to non ERC721Receiver implementer", + "\\\"\\n " + ], + [ + "Aux(address owner, uint64 ", + "aux" + ], + [ + ";\\n\\n // Mapping owner address to token count", + "\\n " + ], + [ + "UniswapV2Library.pairFor", + "(factory" + ], + [ + "cannot exceed 2**256 - 1 (max value of ", + "uint256" + ], + [ + "%", + " and " + ], + [ + ")", + "=" + ], + [ + ".", + "pdf" + ], + [ + "/", + "28, " + ], + [ + "5", + "2" + ], + [ + "B", + "E" + ], + [ + "C", + "ardinality" + ], + [ + "I", + "Token" + ], + [ + "I", + "_SUBSCRIPTION" + ], + [ + "K", + "it" + ], + [ + "L", + "IN" + ], + [ + "_", + "withdraw" + ], + [ + "`", + "leaves" + ], + [ + "`", + "secp256k1` " + ], + [ + "h", + "h" + ], + [ + "r", + "on" + ], + [ + "s", + "1 and " + ], + [ + "t", + "b" + ], + [ + "v", + " to " + ], + [ + "y", + "el" + ], + [ + "z", + " = " + ], + [ + "÷", + " 2 + 1" + ], + [ + "in", + "flation" + ], + [ + ", ", + "length" + ], + [ + "ou", + "s" + ], + [ + "25", + "E8" + ], + [ + ") ", + "or " + ], + [ + ");", + "\\r\\n " + ], + [ + "function ", + "arguments." + ], + [ + "a ", + "part of a " + ], + [ + ": ", + "r" + ], + [ + ": ", + "v " + ], + [ + "wa", + "it " + ], + [ + "transfer", + "Amount" + ], + [ + "if", + "y " + ], + [ + "bytes", + "(_" + ], + [ + "in ", + "any other " + ], + [ + "not ", + "burned" + ], + [ + ". ", + "It " + ], + [ + "index", + "In" + ], + [ + "and ", + "make the " + ], + [ + "set", + "RoleAdmin" + ], + [ + "private ", + "key" + ], + [ + "), ", + "defin" + ], + [ + "), ", + "return the " + ], + [ + "as ", + "a s" + ], + [ + "cl", + "iff" + ], + [ + "a s", + "wap" + ], + [ + "low", + "paper/" + ], + [ + "Call", + "er " + ], + [ + "its ", + "by " + ], + [ + "'s ", + "method " + ], + [ + "mapping", + ", " + ], + [ + "IN", + "T" + ], + [ + "(_", + "name, _symbol" + ], + [ + "If ", + "your library " + ], + [ + "tax", + " " + ], + [ + "interface ", + "of " + ], + [ + "ED", + "CE" + ], + [ + "24", + "0" + ], + [ + "timestamp", + " in the " + ], + [ + ", and ", + "for v" + ], + [ + "current ", + "libraries " + ], + [ + "denominator", + " + 1" + ], + [ + "BB", + "FD" + ], + [ + ".\\n ", + "address addr" + ], + [ + "man", + "u" + ], + [ + "ethereum", + ".github.io/" + ], + [ + ".length", + "; i++" + ], + [ + "Mo", + "de " + ], + [ + "s-", + "value" + ], + [ + "s-", + "value in the " + ], + [ + "s-", + "values in the " + ], + [ + "proof", + ".length; i++) {\\n " + ], + [ + "27", + "/28, " + ], + [ + ") internal view virtual ", + "{\\n " + ], + [ + "dep", + "end" + ], + [ + "signature", + "s with " + ], + [ + "EC", + "ON" + ], + [ + "tokensFor", + "Treasury" + ], + [ + "signature ", + "with an " + ], + [ + "signature ", + "malle" + ], + [ + "was ", + "signed by the " + ], + [ + "fl", + "ip " + ], + [ + "our ", + "target " + ], + [ + "these ", + "malleable " + ], + [ + "98", + "d" + ], + [ + "98", + "1 " + ], + [ + "operation ", + "did not succeed" + ], + [ + "ERC20 ", + "operation did not succeed" + ], + [ + "_check", + "points" + ], + [ + "also ", + "generates " + ], + [ + ");\\n\\n // ", + "Overflow not possible, as _burnCounter cannot be exceed _currentIndex " + ], + [ + "writ", + "e it " + ], + [ + "ased ", + "on " + ], + [ + ",\\n string memory ", + "_symbol" + ], + [ + ";\\n uint256 ", + "tokenIndex" + ], + [ + "AC", + "K" + ], + [ + "████", + "█" + ], + [ + "▓▓", + "▓" + ], + [ + "ix", + " F" + ], + [ + ".sol\\\";\\n\\n", + "interface I" + ], + [ + "Cre", + "dit" + ], + [ + "14", + "1 - " + ], + [ + "48", + "A03" + ], + [ + "28", + "}. " + ], + [ + "28", + " or" + ], + [ + "prec", + "on" + ], + [ + "If the ", + "signature is valid " + ], + [ + ") {\\n return ", + "retval == " + ], + [ + "Registry", + "Address" + ], + [ + "{\\n // ", + "The address of the owner" + ], + [ + "startTimestamp", + ";\\n // " + ], + [ + "add ", + "27 to " + ], + [ + ",\\r\\n address ", + "indexed " + ], + [ + "a `", + "hash" + ], + [ + "EIP-", + "2 " + ], + [ + "ecrecover", + "(). " + ], + [ + "TokenOwnership ", + "{\\n // The address of the owner" + ], + [ + " {", + "27, " + ], + [ + "FE", + "BAA" + ], + [ + "S ", + "========== */" + ], + [ + "Ethereum ", + "Yellow " + ], + [ + "signatures", + ", such as " + ], + [ + "revert(\\\"", + "ERC721: transfer to non ERC721Receiver implementer" + ], + [ + "92", + "36" + ], + [ + "upper ", + "range, " + ], + [ + "ERC721.ownerOf(tokenId", + "), to, tokenId" + ], + [ + "feeNumerator", + "` cannot be greater than the fee denominator" + ], + [ + "/*//////////////////////////////////////////////////////////////", + "/" + ], + [ + "instead ", + "27/28, " + ], + [ + "en\\n * ", + "transferred to `to`.\\n * - When `from" + ], + [ + " == 0) {\\n ", + "return " + ], + [ + "protocol ", + "fees" + ], + [ + ". If ", + "your library " + ], + [ + "minted for `to`.\\n * - When `to", + "` is zero, `tokenId` has been " + ], + [ + "Not ", + "all " + ], + [ + " in the ", + "Ethereum Yellow " + ], + [ + "thus ", + "need " + ], + [ + "malleable ", + "signatures, such as " + ], + [ + "a new ", + "s-value" + ], + [ + "_balances[recipient", + "] += amount" + ], + [ + "v ", + "instead 27/28, " + ], + [ + "signatures ", + "as well" + ], + [ + "Sets ", + "`value` " + ], + [ + "expi", + "red " + ], + [ + ") private {\\n // ", + "To prevent a gap" + ], + [ + "cp", + "." + ], + [ + "Strings.", + "toString(" + ], + [ + "\\n * {", + "ERC721Enumerable}." + ], + [ + "burned by `from`.\\n * - `from` and `to` are never both zero.\\n */\\n function _", + "afterTokenTransfers(\\n address from,\\n address to,\\n uint256 startTokenId,\\n uint256 quantity\\n " + ], + [ + "Out(", + "uint amountIn" + ], + [ + "\\n * @author ", + "M" + ], + [ + "s < ", + "secp256k1n " + ], + [ + "Dig", + "ital " + ], + [ + "https://eips.ethereum.org/EIPS/eip-2612", + "#specification" + ], + [ + "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", + "FEBAA" + ], + [ + ";\\n\\n constructor(", + ") {\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and " + ], + [ + "generates ", + "malleable signatures, such as " + ], + [ + "revert(add(32, reason), mload(reason", + "))\\n }\\n }\\n " + ], + [ + "calculate ", + "a new s-value" + ], + [ + "(bytes32 _", + "key" + ], + [ + "if (!_exists(tokenId)) revert ", + "ApprovalQueryForNonexistentToken" + ], + [ + "(https://", + "ethereum.github.io/" + ], + [ + "nCheckpoints ", + "- 1]." + ], + [ + "paper", + ".pdf" + ], + [ + "` is zero, `tokenId` has been ", + "minted for `to`.\\n * - When `to` is zero, `tokenId` has been " + ], + [ + "CANONICAL", + "_COR" + ], + [ + ", created from ", + "a `hash" + ], + [ + "27 to ", + "28 or" + ], + [ + "unique. ", + "Append" + ], + [ + "Weighted", + "Pool" + ], + [ + "364", + "141 - " + ], + [ + "Remove ", + "this possibility " + ], + [ + "Returns an Ethereum Signed Message", + ", created from a `hash" + ], + [ + "token/ERC20/ERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.", + "openzeppelin.com/" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Call", + "data version of {" + ], + [ + ";\\n ", + "}" + ], + [ + "unique ", + "signature with an " + ], + [ + "FixedPoint.", + "ONE" + ], + [ + "with minimal overhead for tokenomics.\\n uint64 ", + "startTimestamp;\\n // " + ], + [ + "2)", + ": v " + ], + [ + "still allows ", + "signature malle" + ], + [ + "at `index", + "`.\\n */\\n function " + ], + [ + "ed\\n // ", + "more than " + ], + [ + "1 for ", + "v instead 27/28, " + ], + [ + "uint256) {\\n // Counter underflow is impossible as ", + "_burnCounter cannot be increment" + ], + [ + "Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension", + ", but not including the Enumerable extension, which is available separately as" + ], + [ + "tokenId < _", + "currentIndex" + ], + [ + "IRE", + "D" + ], + [ + "bigg", + "est " + ], + [ + "Shif", + "t in bits from prod1 into " + ], + [ + "ability for ", + "ecrecover(). " + ], + [ + "can use ", + "this function" + ], + [ + "over time", + ".\\n */\\n function " + ], + [ + ".\\n * It ", + "gradually moves to O(1) as tokens get transferred around " + ], + [ + "malleable", + "), return the " + ], + [ + "sale price", + ". " + ], + [ + "with 0x", + "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAA" + ], + [ + "Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuard {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status", + ";\\n\\n constructor() {\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and " + ], + [ + "\"ipf", + "s\"" + ], + [ + "address receiver", + ", uint256 royaltyAmount" + ], + [ + ").\\n */\\ncontract ", + "ERC721A" + ], + [ + "0 < ", + "s < secp256k1n " + ], + [ + ".\\n bool ", + "burned" + ], + [ + "signatures from ", + "current libraries " + ], + [ + "This also deletes the contents at the last position of the array", + "\\n delete " + ], + [ + "[lastTokenId] = tokenIndex; // Update the moved token", + "'s index" + ], + [ + "vice versa", + ". If your library " + ], + [ + "(and not ", + "malleable), return the " + ], + [ + "0/", + "1 for v instead 27/28, " + ], + [ + "v`, `", + "r` and `s" + ], + [ + "paper ", + "(https://ethereum.github.io/" + ], + [ + "Gas spent here starts off proportional to the maximum mint batch size", + ".\\n * It gradually moves to O(1) as tokens get transferred around " + ], + [ + "6AF", + "48A03" + ], + [ + "`tokenId` has be", + "en\\n * transferred to `to`.\\n * - When `from" + ], + [ + ", please override this function", + ".\\n */\\n function _startTokenId" + ], + [ + "Whether the token has been burned", + ".\\n bool burned" + ], + [ + "start time of ownership ", + "with minimal overhead for tokenomics.\\n uint64 startTimestamp;\\n // " + ], + [ + "CD0", + "364141 - " + ], + [ + "v from ", + "27 to 28 or" + ], + [ + "generate a ", + "unique signature with an " + ], + [ + "1): ", + "0 < s < secp256k1n " + ], + [ + "s `quantity` tokens and transfers them to `to`", + ".\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `quantity` must be greater than 0" + ], + [ + "s1 and ", + "flip " + ], + [ + "v to ", + "accept" + ], + [ + "yel", + "lowpaper/" + ], + [ + "25E8", + "CD0364141 - " + ], + [ + "and make the ", + "signature" + ], + [ + "), defin", + "es" + ], + [ + "If your library ", + "generates malleable signatures, such as " + ], + [ + "EDCE", + "6AF48A03" + ], + [ + "timestamp in the ", + "future" + ], + [ + ", and for v", + " in " + ], + [ + "BBFD", + "25E8CD0364141 - " + ], + [ + "s-value in the ", + "lower half order" + ], + [ + "s-values in the ", + "upper range, " + ], + [ + "signatures with ", + "0/1 for v instead 27/28, " + ], + [ + "these malleable ", + "signatures as well" + ], + [ + "also generates ", + "signatures with 0/1 for v instead 27/28, " + ], + [ + "ix F", + " in the Ethereum Yellow " + ], + [ + "28}. ", + "Most" + ], + [ + "If the signature is valid ", + "(and not malleable), return the " + ], + [ + "add 27 to ", + "v to accept" + ], + [ + "EIP-2 ", + "still allows signature malle" + ], + [ + "TokenOwnership {\\n // The address of the owner", + ".\\n address addr" + ], + [ + " {27, ", + "28}. Most" + ], + [ + "paper.pdf", + "), defines" + ], + [ + "` is zero, `tokenId` has been minted for `to`.\\n * - When `to` is zero, `tokenId` has been ", + "burned by `from`.\\n * - `from` and `to` are never both zero.\\n */\\n function _afterTokenTransfers(\\n address from,\\n address to,\\n uint256 startTokenId,\\n uint256 quantity\\n " + ], + [ + "CANONICAL_COR", + "I_SUBSCRIPTION" + ], + [ + "unique. Append", + "ix F in the Ethereum Yellow " + ], + [ + "Remove this possibility ", + "and make the signature" + ], + [ + "uint256) {\\n // Counter underflow is impossible as _burnCounter cannot be increment", + "ed\\n // more than " + ], + [ + "Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as", + "\\n * {ERC721Enumerable}." + ], + [ + "ability for ecrecover(). ", + "Remove this possibility and make the signature" + ], + [ + "with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAA", + "EDCE6AF48A03" + ], + [ + "signatures from current libraries ", + "generate a unique signature with an " + ], + [ + "vice versa. If your library ", + "also generates signatures with 0/1 for v instead 27/28, " + ], + [ + "paper (https://ethereum.github.io/", + "yellowpaper/" + ], + [ + "`tokenId` has been\\n * transferred to `to`.\\n * - When `from", + "` is zero, `tokenId` has been minted for `to`.\\n * - When `to` is zero, `tokenId` has been burned by `from`.\\n * - `from` and `to` are never both zero.\\n */\\n function _afterTokenTransfers(\\n address from,\\n address to,\\n uint256 startTokenId,\\n uint256 quantity\\n " + ], + [ + "start time of ownership with minimal overhead for tokenomics.\\n uint64 startTimestamp;\\n // ", + "Whether the token has been burned.\\n bool burned" + ], + [ + "s1 and flip ", + "v from 27 to 28 or" + ], + [ + "If your library generates malleable signatures, such as ", + "s-values in the upper range, " + ], + [ + "BBFD25E8CD0364141 - ", + "s1 and flip v from 27 to 28 or" + ], + [ + "If the signature is valid (and not malleable), return the ", + "signer address" + ], + [ + "EIP-2 still allows signature malle", + "ability for ecrecover(). Remove this possibility and make the signature" + ], + [ + "unique. Appendix F in the Ethereum Yellow ", + "paper (https://ethereum.github.io/yellowpaper/" + ], + [ + "with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03", + "BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or" + ], + [ + "signatures from current libraries generate a unique signature with an ", + "s-value in the lower half order" + ], + [ + "vice versa. If your library also generates signatures with 0/1 for v instead 27/28, ", + "add 27 to v to accept" + ], + [ + "If your library generates malleable signatures, such as s-values in the upper range, ", + "calculate a new s-value" + ], + [ + "unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/", + "paper.pdf), defines" + ], + [ + " ", + "such" + ], + [ + "(", + "WETH" + ], + [ + "(", + ");\\n }\\n\\n /**\\n * @notice " + ], + [ + "(", + ");\\n }\\n\\n function _" + ], + [ + "(", + "precision " + ], + [ + ")", + "` with " + ], + [ + ",", + "'" + ], + [ + ",", + "\\r\\n " + ], + [ + "-", + "specific " + ], + [ + "-", + "formatted " + ], + [ + "/", + "9236" + ], + [ + "8", + "00" + ], + [ + "D", + "7" + ], + [ + "E", + "ll" + ], + [ + "E", + "very " + ], + [ + "F", + "i" + ], + [ + "M", + "O" + ], + [ + "M", + "ech" + ], + [ + "P", + "lease " + ], + [ + "S", + "mar" + ], + [ + "S", + "ource " + ], + [ + "S", + ". W" + ], + [ + "_", + ", uint256 " + ], + [ + "_", + "who" + ], + [ + "`", + "_data" + ], + [ + "c", + "s.s" + ], + [ + "l", + "ong " + ], + [ + "m", + "ate " + ], + [ + "s", + "l" + ], + [ + "|", + " " + ], + [ + "~", + "denominator + 1" + ], + [ + "∈", + " {27, 28}. Most" + ], + [ + "\\n ", + "returns (bool)\\n {\\n " + ], + [ + "ad", + "mit " + ], + [ + "ed", + "its by " + ], + [ + ") ", + "operation" + ], + [ + "ER", + "R" + ], + [ + "\\\"", + "msb" + ], + [ + "address ", + "of " + ], + [ + "from", + ") revert " + ], + [ + "im", + "medi" + ], + [ + "ip", + "tic " + ], + [ + "no", + "-" + ], + [ + "er ", + "11" + ], + [ + "account", + " == " + ], + [ + "return ", + "min(" + ], + [ + ",\\n ", + " " + ], + [ + "in ", + "modular " + ], + [ + "es ", + "at" + ], + [ + ". ", + "Now that denominator is an odd number, it has an " + ], + [ + "In", + "clude " + ], + [ + "32", + " is the " + ], + [ + "con", + "ve" + ], + [ + " to ", + "turn " + ], + [ + "), ", + "following the selected rounding direction" + ], + [ + "that ", + "denominator * inv = 1 " + ], + [ + "All", + "ow " + ], + [ + "/ ", + "denominator" + ], + [ + "with ", + "further " + ], + [ + "symbol", + " = " + ], + [ + "Mint", + "er " + ], + [ + "'s ", + "\\\"Hacker's Delight" + ], + [ + "eth", + "ers" + ], + [ + " (", + "ECDSA" + ], + [ + "of the ", + "target" + ], + [ + "of the ", + "private key" + ], + [ + "numb", + "er is not a " + ], + [ + "safe", + "Add" + ], + [ + ";\\n ", + "} else {\\n " + ], + [ + "result ", + "with one bit of precision" + ], + [ + "(_", + "editionId" + ], + [ + "\\n // ", + "An empty struct value does not necessarily mean the token is unowned" + ], + [ + "in the ", + "function" + ], + [ + "deadline", + "` must be a " + ], + [ + "block.", + "number " + ], + [ + "tw", + "itter" + ], + [ + "result", + "` is an " + ], + [ + "Sell", + "ToAdd" + ], + [ + "viou", + "s" + ], + [ + "number of ", + "pair" + ], + [ + " and ", + "mod 2^256" + ], + [ + " and ", + "compute " + ], + [ + ");\\r\\n", + "\\r\\n event " + ], + [ + "tion ", + "with one bit of precision" + ], + [ + "Sta", + "ke " + ], + [ + "we ", + "have" + ], + [ + "++", + ", _data" + ], + [ + "baseURI", + "_" + ], + [ + ";\\n\\n ", + "assembly {\\n " + ], + [ + "Dev", + "Wallet" + ], + [ + "For ", + "our " + ], + [ + "signature ", + "above" + ], + [ + "signature ", + "format" + ], + [ + "pt", + "er 11" + ], + [ + "count", + "ing " + ], + [ + ")\\n ", + "mstore(0x" + ], + [ + "our ", + "partial " + ], + [ + "true ", + "value is a " + ], + [ + " + ", + "prod0." + ], + [ + "into ", + "the expected " + ], + [ + "uint64", + ".\\n */\\n function _set" + ], + [ + "first ", + "guess" + ], + [ + "MASK", + "_" + ], + [ + "message ", + "was signed by the " + ], + [ + "(from, to, tokenId", + ");\\n _afterTokenTransfers" + ], + [ + "2^", + "4." + ], + [ + "also ", + "under MIT licen" + ], + [ + "which is ", + "smaller than the " + ], + [ + "\\\");\\n return ", + "owner" + ], + [ + "inverse ", + "= (" + ], + [ + "inverse ", + "modulo 2^256" + ], + [ + "\\n /// @param ", + "amount" + ], + [ + "on the ", + "signature format" + ], + [ + "before ", + "the " + ], + [ + "Cha", + "pter 11" + ], + [ + "is the ", + "square root of a " + ], + [ + " / ", + "twos" + ], + [ + "refer", + "ral" + ], + [ + "_P", + "ERCENT" + ], + [ + "2^256", + " + prod0." + ], + [ + "2^256", + " / twos" + ], + [ + "\\\");", + " // " + ], + [ + "royalty ", + "= _" + ], + [ + "--------------------------------", + "----------------" + ], + [ + "EIP712", + "-formatted " + ], + [ + " - 1", + ", then " + ], + [ + "support ", + "ERC165 " + ], + [ + "(address _", + "account" + ], + [ + ").\\n * ", + "If there are multiple variables, please pack them into a " + ], + [ + "over the ", + "EIP712-formatted " + ], + [ + ". Th", + "anks to Hensel's lifting lemma, this also work" + ], + [ + ", we ", + "get the " + ], + [ + "division", + " of two unsigned integers, " + ], + [ + "string memory) {\\n ", + "if (!_exists(tokenId)) revert URIQueryForNonexistentToken();\\n\\n " + ], + [ + "`.\\n */\\n function _", + "numberBurned" + ], + [ + "TokenOwnership ", + "storage " + ], + [ + "hel", + "d " + ], + [ + "number ", + "`a" + ], + [ + " L", + "abs " + ], + [ + "ratio", + " * " + ], + [ + " != 0", + ") ratio" + ], + [ + "Uniswap", + " Labs " + ], + [ + "correct ", + "for" + ], + [ + "correct ", + "bit" + ], + [ + "inverse *= 2 - denominator * inverse; // inverse mod ", + "2^256" + ], + [ + ". We ", + "know the " + ], + [ + ". We ", + "don't need to compute the high bits of the result and prod1" + ], + [ + "Does not ", + "overflow because the " + ], + [ + "can be used to ", + "verify that a " + ], + [ + "that the ", + "\\\"msb" + ], + [ + " = (", + "ratio * " + ], + [ + "denominator ", + "with full precision" + ], + [ + "denominator ", + "& (" + ], + [ + "denominator ", + "cannot be zero " + ], + [ + "balanceOf(address(this", + "));\\n " + ], + [ + "ict", + "ed" + ], + [ + "mulDiv", + "(x, y, " + ], + [ + "uint128 ", + "result" + ], + [ + "paused ", + "= true" + ], + [ + "prod0 ", + "/ denominator" + ], + [ + "inverse *= 2 - denominator * inverse; // inverse mod 2^", + "8" + ], + [ + "type ", + "signature above" + ], + [ + "\\n }\\n ", + "} while (" + ], + [ + "sqrt(a", + ")` with " + ], + [ + "sqrt(a", + "), following the selected rounding direction" + ], + [ + ",\\n // ", + "and it is initialized to " + ], + [ + "paus", + "able " + ], + [ + "whenever ", + "a " + ], + [ + "guarante", + "e that the " + ], + [ + "reconstruct the ", + "512 bit result. The result is stored in two 256" + ], + [ + ", msg.sender", + ", " + ], + [ + ".\\n *\\n * @param ", + "seaDropImpl" + ], + [ + ". If ", + "twos is zero, then it becomes " + ], + [ + "every ", + "iteration" + ], + [ + "remainder of dividing two unsigned integ", + "ers, " + ], + [ + "mod 2^256", + ". Compute the " + ], + [ + "mod 2^256", + ". Now that denominator is an odd number, it has an " + ], + [ + "mod 2^256", + " and mod 2^256" + ], + [ + "CAUTION: ", + "Not all " + ], + [ + ".\\n // ", + "The " + ], + [ + "(address to", + ") external returns (" + ], + [ + "Inspired by ", + "Hen" + ], + [ + "Reverts ", + "if the " + ], + [ + "_owners", + ";\\n\\n // Mapping owner address to token count\\n " + ], + [ + "such that ", + "we have" + ], + [ + ".addr", + " = " + ], + [ + "].sub(amount, \\\"ERC20: ", + "burn " + ], + [ + "square root ", + "of the target" + ], + [ + "mulmod(x, y, ", + "denominator" + ], + [ + "mulmod(x, y, ", + "denominator) " + ], + [ + "mulmod(x, y, ", + "not(0" + ], + [ + "(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n require(b", + " <= a, errorMessage" + ], + [ + "at most ", + "7 iteration" + ], + [ + "var", + "-name-mixedcase" + ], + [ + "\\\" (", + "most significant bit" + ], + [ + "\\\" (", + "Chapter 11" + ], + [ + "s of a ", + "given address" + ], + [ + "0,\\n 0,\\n ", + "0,\\n 0,\\n " + ], + [ + "since it ", + "is the square root of a " + ], + [ + "automatedMarketMakerPairs[", + "from] " + ], + [ + "x * ", + "y / " + ], + [ + "result * ", + "result < " + ], + [ + ") of ", + "our target " + ], + [ + ". Al", + "ways >= 1" + ], + [ + "y / ", + "denominator) with full precision. Throws if result overflows a uint256 or denominator == 0" + ], + [ + "red to ", + "support ERC165 " + ], + [ + ") internal virtual override {\\n ", + "super._" + ], + [ + "prevents ", + "denominator == " + ], + [ + "_balances[sender] = ", + "senderBalance - amount" + ], + [ + "stage ", + "in the function" + ], + [ + "This will ", + "give " + ], + [ + "product ", + "mod 2^256 and mod 2^256" + ], + [ + "(https://", + "xn--2-umb.com/21/muldiv" + ], + [ + "See https://", + "cs.s" + ], + [ + "doubl", + "es at" + ], + [ + "\\n * of ", + "returning `false` on failure. This behavior is nonetheless convention" + ], + [ + "Newton", + "'s method " + ], + [ + "prod0 := ", + "mul(x, y" + ], + [ + "less than 2^256", + ". Also " + ], + [ + "less than 2^256", + ", this is the final result" + ], + [ + "twos ", + "such that it is " + ], + [ + ";\\n\\n // Mapping owner address to ", + "address data" + ], + [ + "square root of a ", + "number" + ], + [ + "this extension's ", + "token tracking data structures" + ], + [ + ", // Toward ", + "negative " + ], + [ + "/blob/", + "main/src/" + ], + [ + "`msb(a", + ") <= a < " + ], + [ + ". Compute the ", + "product mod 2^256 and mod 2^256" + ], + [ + "modulo 2^256", + ". Since the " + ], + [ + "power of 2 ", + "which is smaller than the " + ], + [ + "power of 2 ", + "such that we have" + ], + [ + "2**(k/2", + ") <= sqrt(a) < " + ], + [ + ";\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to ", + "ownership details" + ], + [ + "lz", + "Endpoint" + ], + [ + "multiplying ", + "with the modular inverse of denominator" + ], + [ + "trusted", + "Remote" + ], + [ + "These functions ", + "can be used to verify that a " + ], + [ + ".\\n */\\n function _total", + "Minted(" + ], + [ + "ry ", + "S. W" + ], + [ + "ation of `", + "sqrt(a)` with " + ], + [ + "REC", + "IPIENT" + ], + [ + "Scri", + "pt " + ], + [ + "`owner`.\\n */\\n function _", + "numberMinted" + ], + [ + "Collect", + "ed" + ], + [ + "decla", + "red to support ERC165 " + ], + [ + "bond", + "ing" + ], + [ + "uint256 currentAllowance = ", + "_allowances[_msgSender()][spender" + ], + [ + "138", + "556" + ], + [ + "Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had", + " been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account" + ], + [ + "Curve ", + "Digital " + ], + [ + "at least 1 ", + "correct bit" + ], + [ + "result, ", + "a / result" + ], + [ + "Signature ", + "Algorithm" + ], + [ + "us the ", + "correct result " + ], + [ + "maxBatch", + "Size" + ], + [ + "(a ", + "- 1) / b" + ], + [ + "). We ", + "thus need " + ], + [ + ".sol\\\";\\nimport \\\"../../utils/Address", + ".sol\\\";\\nimport \\\"../../" + ], + [ + "External ", + "interface of " + ], + [ + "merkle trees ", + "admit " + ], + [ + "];\\n\\n emit Transfer", + "(owner, address(0), tokenId" + ], + [ + "at this ", + "stage in the function" + ], + [ + "minted by ", + "`owner`.\\n */\\n function _numberMinted" + ], + [ + "(x * ", + "y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0" + ], + [ + ", J", + "r." + ], + [ + "[WARNING", + "]\\n * ====\\n * " + ], + [ + "arren", + ", Jr." + ], + [ + "We know ", + "that the \\\"msb" + ], + [ + "converges ", + "quadratically " + ], + [ + "al\\n * ", + "and does not conflict with the expectations of ERC20 " + ], + [ + "require(denominator", + " > prod1" + ], + [ + "bytes of ", + "hash" + ], + [ + "outcome ", + "is" + ], + [ + "estima", + "tion with one bit of precision" + ], + [ + "tackexchange.com/", + "q/" + ], + [ + "cred", + "it to Remco Bloemen under MIT license " + ], + [ + "length in ", + "bytes of hash" + ], + [ + "Use the ", + "Newton-Raphson iteration to improve the precision" + ], + [ + "(\\n bytes32 poolId,\\n address ", + "sender,\\n address recipient" + ], + [ + "At this point `", + "result` is an " + ], + [ + "` is a ", + "power of 2 such that we have" + ], + [ + "x * y", + ". Compute the product mod 2^256 and mod 2^256" + ], + [ + "OpenZeppelin guidelines: functions revert instead", + "\\n * of returning `false` on failure. This behavior is nonetheless convention" + ], + [ + "2*", + "msb(a" + ], + [ + "Original ", + "credit to Remco Bloemen under MIT license " + ], + [ + "ditions ", + "guarantee that the " + ], + [ + "twos = ", + "denominator & (" + ], + [ + "remainder := ", + "mulmod(x, y, denominator" + ], + [ + "Calculates floor", + "(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0" + ], + [ + "total amount of tokens minted in the contract", + ".\\n */\\n function _totalMinted(" + ], + [ + "512-bit multiply [prod1 prod0] = ", + "x * y. Compute the product mod 2^256 and mod 2^256" + ], + [ + "Make sure the result is ", + "less than 2^256. Also " + ], + [ + "Invert denominator ", + "mod 2^256. Now that denominator is an odd number, it has an " + ], + [ + "result = prod0 * ", + "inverse" + ], + [ + "let mm := ", + "mulmod(x, y, not(0" + ], + [ + "largest power of two divisor of denominator", + ". Always >= 1" + ], + [ + "variables such that product = prod1 * ", + "2^256 + prod0." + ], + [ + "Make division exact by subtracting the remainder from [prod1 prod0", + "]." + ], + [ + "perfect square, the ", + "value is " + ], + [ + "four bits. That is, denominator * inv = 1 mod ", + "2^4." + ], + [ + "Factor powers of two out of denominator", + " and compute " + ], + [ + "Because the division is now exact we can divide by ", + "multiplying with the modular inverse of denominator" + ], + [ + "inverse by starting with a seed that is ", + "correct for" + ], + [ + "use the Chinese Remainder Theorem to ", + "reconstruct the 512 bit result. The result is stored in two 256" + ], + [ + "uint256. ", + "Newton's method " + ], + [ + "does not decrement", + ",\\n // and it is initialized to " + ], + [ + "A helper ", + "function to " + ], + [ + "delete _owners[tokenId", + "];\\n\\n emit Transfer(owner, address(0), tokenId" + ], + [ + "Flip ", + "twos such that it is " + ], + [ + "a == 0 ? 0 : ", + "(a - 1) / b" + ], + [ + "burned by or on behalf of `owner", + "`.\\n */\\n function _numberBurned" + ], + [ + ").\\n */\\n function _get", + "Aux(address owner) internal view returns (uint64" + ], + [ + "enforced by the ", + "type signature above" + ], + [ + "For more information ", + "on the signature format" + ], + [ + "cannot exceed 2**256 - 1 (max value of uint256", + ").\\n */\\ncontract ERC721A" + ], + [ + "`secp256k1` ", + "signature from " + ], + [ + "÷ 2 + 1", + ", and for v in " + ], + [ + "precon", + "ditions guarantee that the " + ], + [ + "Sets `value` ", + "as the allowance of `spender` " + ], + [ + "2): v ", + "∈ {27, 28}. Most" + ], + [ + "biggest ", + "power of 2 which is smaller than the " + ], + [ + "v`, `r` and `s", + "` must be a valid " + ], + [ + ", please override this function.\\n */\\n function _startTokenId", + "() internal view virtual returns (uint256) {\\n return 0" + ], + [ + "1): 0 < s < secp256k1n ", + "÷ 2 + 1, and for v in " + ], + [ + "Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.", + "\\n */\\ncontract ERC721" + ], + [ + "(precision ", + "doubles at" + ], + [ + "/9236", + "3." + ], + [ + "Ell", + "iptic " + ], + [ + "edits by ", + "Uniswap Labs " + ], + [ + "return min(", + "result, a / result" + ], + [ + "in modular ", + "arithmetic, doubling the correct bits in each step" + ], + [ + "32 is the ", + "length in bytes of hash" + ], + [ + " to turn ", + "our partial " + ], + [ + "that denominator * inv = 1 ", + "mod 2^256. Compute the " + ], + [ + "with further ", + "edits by Uniswap Labs " + ], + [ + "'s \\\"Hacker's Delight", + "\\\" (Chapter 11" + ], + [ + " (ECDSA", + ") operation" + ], + [ + "of the private key", + "s of a given address" + ], + [ + "number is not a ", + "perfect square, the value is " + ], + [ + "deadline` must be a ", + "timestamp in the future" + ], + [ + "SellToAdd", + "To" + ], + [ + "For our ", + "first guess" + ], + [ + "true value is a ", + "uint128" + ], + [ + "into the expected ", + "uint128 result" + ], + [ + "uint64.\\n */\\n function _set", + "Aux(address owner, uint64 aux" + ], + [ + "message was signed by the ", + "holder" + ], + [ + "(from, to, tokenId);\\n _afterTokenTransfers", + "(from, to, tokenId, 1" + ], + [ + "also under MIT licen", + "se" + ], + [ + "inverse = (", + "3 * denominator) ^ 2" + ], + [ + "inverse modulo 2^256", + " such" + ], + [ + "2^256 / twos", + ". If twos is zero, then it becomes " + ], + [ + " - 1, then ", + "use" + ], + [ + ").\\n * If there are multiple variables, please pack them into a ", + "uint64.\\n */\\n function _setAux(address owner, uint64 aux" + ], + [ + "over the EIP712-formatted ", + "function arguments." + ], + [ + ", we get the ", + "biggest power of 2 which is smaller than the " + ], + [ + "number `a", + "` is a power of 2 such that we have" + ], + [ + " != 0) ratio", + " = (ratio * " + ], + [ + ". We know the ", + "true value is a uint128" + ], + [ + "Does not overflow because the ", + "denominator cannot be zero " + ], + [ + "denominator with full precision", + ", following the selected rounding direction" + ], + [ + "mulDiv(x, y, ", + "denominator" + ], + [ + "every iteration", + "). We thus need " + ], + [ + "CAUTION: Not all ", + "merkle trees admit " + ], + [ + "Inspired by Hen", + "ry S. W" + ], + [ + "at most 7 iteration", + " to turn our partial " + ], + [ + "\\\" (most significant bit", + ") of our target " + ], + [ + "since it is the square root of a ", + "uint256. Newton's method " + ], + [ + "x * y / ", + "denominator with full precision, following the selected rounding direction" + ], + [ + "This will give ", + "us the correct result " + ], + [ + "See https://cs.s", + "tackexchange.com/q/" + ], + [ + "less than 2^256, this is the final result", + ". We don't need to compute the high bits of the result and prod1" + ], + [ + "`msb(a) <= a < ", + "2*msb(a" + ], + [ + "modulo 2^256. Since the ", + "preconditions guarantee that the " + ], + [ + ";\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to ownership details", + "\\n // An empty struct value does not necessarily mean the token is unowned" + ], + [ + "These functions can be used to verify that a ", + "message was signed by the holder" + ], + [ + "ation of `sqrt(a)` with ", + "at least 1 correct bit" + ], + [ + "declared to support ERC165 ", + "detection" + ], + [ + "138556", + "/92363." + ], + [ + "Curve Digital ", + "Signature Algorithm" + ], + [ + "External interface of ", + "AccessControl" + ], + [ + "arren, Jr.", + "'s \\\"Hacker's Delight\\\" (Chapter 11" + ], + [ + "We know that the \\\"msb", + "\\\" (most significant bit) of our target " + ], + [ + "converges quadratically ", + "(precision doubles at" + ], + [ + "estimation with one bit of precision", + ". We know the true value is a uint128" + ], + [ + "Use the Newton-Raphson iteration to improve the precision", + ". Thanks to Hensel's lifting lemma, this also work" + ], + [ + "At this point `result` is an ", + "estimation with one bit of precision. We know the true value is a uint128" + ], + [ + "OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless convention", + "al\\n * and does not conflict with the expectations of ERC20 " + ], + [ + "Original credit to Remco Bloemen under MIT license ", + "(https://xn--2-umb.com/21/muldiv" + ], + [ + "twos = denominator & (", + "~denominator + 1" + ], + [ + "512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256", + " - 1, then use" + ], + [ + "Make sure the result is less than 2^256. Also ", + "prevents denominator == " + ], + [ + "Invert denominator mod 2^256. Now that denominator is an odd number, it has an ", + "inverse modulo 2^256 such" + ], + [ + "Factor powers of two out of denominator and compute ", + "largest power of two divisor of denominator. Always >= 1" + ], + [ + "Flip twos such that it is ", + "2^256 / twos. If twos is zero, then it becomes " + ], + [ + "a == 0 ? 0 : (a - 1) / b", + " + 1" + ], + [ + "For more information on the signature format", + ", see " + ], + [ + "Elliptic ", + "Curve Digital Signature Algorithm" + ], + [ + "that denominator * inv = 1 mod 2^256. Compute the ", + "inverse by starting with a seed that is correct for" + ], + [ + "with further edits by Uniswap Labs ", + "also under MIT license" + ], + [ + "For our first guess", + ", we get the biggest power of 2 which is smaller than the " + ], + [ + "Does not overflow because the denominator cannot be zero ", + "at this stage in the function" + ], + [ + "every iteration). We thus need ", + "at most 7 iteration to turn our partial " + ], + [ + "CAUTION: Not all merkle trees admit ", + "multiproof" + ], + [ + "Inspired by Henry S. W", + "arren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11" + ], + [ + "since it is the square root of a uint256. Newton's method ", + "converges quadratically (precision doubles at" + ], + [ + "This will give us the correct result ", + "modulo 2^256. Since the preconditions guarantee that the " + ], + [ + "See https://cs.stackexchange.com/q/", + "138556/92363." + ], + [ + "We know that the \\\"msb\\\" (most significant bit) of our target ", + "number `a` is a power of 2 such that we have" + ], + [ + "Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes ", + "on" + ], + [ + "Elliptic Curve Digital Signature Algorithm", + " (ECDSA) operation" + ], + [ + "For our first guess, we get the biggest power of 2 which is smaller than the ", + "square root of the target" + ], + [ + "every iteration). We thus need at most 7 iteration to turn our partial ", + "result with one bit of precision" + ], + [ + "This will give us the correct result modulo 2^256. Since the preconditions guarantee that the ", + "outcome is" + ], + [ + "\"", + "pragma solidity >=" + ], + [ + "(", + "new" + ], + [ + "1", + ");\\n }\\n }\\n\\n /**\\n * @dev " + ], + [ + "E", + "G" + ], + [ + "S", + "a" + ], + [ + "[", + "relevant " + ], + [ + "]", + ";\\r\\n require(" + ], + [ + "_", + "DE" + ], + [ + "_", + "revert(" + ], + [ + "_", + "contractBalance" + ], + [ + "a", + "13" + ], + [ + "a", + ", b" + ], + [ + "a", + "3c" + ], + [ + "c", + "7" + ], + [ + "d", + "ro" + ], + [ + "i", + "us" + ], + [ + "p", + "h" + ], + [ + "p", + "adding" + ], + [ + "p", + "ixel" + ], + [ + "t", + "Total" + ], + [ + "}", + ".\\n */\\n event " + ], + [ + "\\n ", + ") external;\\n\\n function " + ], + [ + " *", + "/\\n " + ], + [ + "th", + "ing " + ], + [ + "in", + "line " + ], + [ + "ac", + "ros" + ], + [ + "return", + "ed by `" + ], + [ + "at", + "m" + ], + [ + "ic", + "al " + ], + [ + "to ", + "non-zero " + ], + [ + "address ", + "or" + ], + [ + "\\n\\n ", + "/**\\n * @notice " + ], + [ + "// ", + "We " + ], + [ + "// ", + "Toward " + ], + [ + "Token", + "Count" + ], + [ + "Re", + "venue" + ], + [ + ".\\n */\\n function ", + "values(" + ], + [ + "not ", + "being emitted " + ], + [ + "address(", + "token" + ], + [ + "token ", + "contract" + ], + [ + "The ", + "b" + ], + [ + "The ", + "same " + ], + [ + "This ", + "variable " + ], + [ + ";\\n\\n", + "\\t" + ], + [ + ";\\n\\n", + "contract " + ], + [ + "ist", + "ro" + ], + [ + " is ", + "allowed" + ], + [ + " _", + "_" + ], + [ + "this ", + "cannot be " + ], + [ + "per", + "son " + ], + [ + "old", + "Allowance " + ], + [ + "Up", + ", // Toward " + ], + [ + "success", + ", \\\"" + ], + [ + "}\\n ", + "revert OwnerQueryForNonexistentToken" + ], + [ + "recei", + "ving " + ], + [ + "Burn", + " " + ], + [ + "__", + "Context" + ], + [ + "timestamp", + " " + ], + [ + "should ", + "never be " + ], + [ + ");\\r\\n ", + "require(" + ], + [ + "called ", + "as " + ], + [ + ".\\n *\\n * ", + "Royalty " + ], + [ + ";\\n\\n /**\\n * @dev ", + "See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(" + ], + [ + "receiver", + " != address(0), \\\"" + ], + [ + "total ", + "reflection" + ], + [ + "\\\");\\n require(", + "to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer" + ], + [ + "true ", + "if " + ], + [ + "metho", + "ds" + ], + [ + "library", + "'s " + ], + [ + "subscri", + "ption " + ], + [ + "36", + "08" + ], + [ + "_currentIndex", + ";\\n\\n // The " + ], + [ + "an address ", + "to " + ], + [ + ".sol\\\";\\nimport \\\"./", + "IERC721Receiver" + ], + [ + "being ", + "used " + ], + [ + "15", + "9" + ], + [ + "1._\\n */\\n function ", + "toInt" + ], + [ + "send ", + "tokens " + ], + [ + "Multi", + "sig" + ], + [ + "quantity ", + "of tokens " + ], + [ + ") internal virtual {", + " " + ], + [ + "(msg.sender, ", + "address(this), " + ], + [ + "99", + "9" + ], + [ + "nonces", + "}" + ], + [ + "issu", + "ing " + ], + [ + ");\\n if (", + "rounding == Rounding.Up && " + ], + [ + "should", + "SwapBack" + ], + [ + "secon", + "d " + ], + [ + ".call{", + " value: " + ], + [ + "Down", + ", // Toward negative " + ], + [ + "_operatorApproval", + "s[owner][operator" + ], + [ + "if(", + "!" + ], + [ + "Emits an {Approval", + "} event" + ], + [ + "} else {\\n ", + "assembly {\\n " + ], + [ + ";\\n }\\n return ", + "result" + ], + [ + "``owner``'s ", + "current nonce " + ], + [ + "_beforeTokenTransfers", + "(from, address(0), tokenId, 1" + ], + [ + "must use ", + "``owner``'s current nonce " + ], + [ + "upgrad", + "e " + ], + [ + "guarante", + "ed to be " + ], + [ + "non-zero ", + "to non-zero " + ], + [ + ") public view override returns (", + "uint256) {\\n return " + ], + [ + "protocol ", + "fee " + ], + [ + ";\\n address public ", + "immutable " + ], + [ + "Cap", + "ital" + ], + [ + "ardi", + "an" + ], + [ + "with custom message ", + "when dividing by " + ], + [ + "_Available since v3.", + "1._\\n */\\n function toInt" + ], + [ + "\\\"\\\"", + ";\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\\n * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\\n * by default, can be " + ], + [ + "_burnCounter", + ";\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to ownership details\\n // An empty struct value does not necessarily mean the token is unowned" + ], + [ + "Zero ", + "// Toward " + ], + [ + "integer division", + " of two unsigned integers, reverting " + ], + [ + "integer division", + " of two unsigned integers, reverting with custom message " + ], + [ + "revert TransferToNonERC721ReceiverImplementer", + "();" + ], + [ + "address owner = ERC721.ownerOf(tokenId", + ");\\n require(to != owner, \\\"ERC721: approval to current owner" + ], + [ + "EnumerableSet.", + "AddressSet " + ], + [ + "f8", + "10" + ], + [ + "();\\n\\n _beforeTokenTransfers", + "(from, to, tokenId, 1" + ], + [ + "\\\");\\n ", + "} else {\\n " + ], + [ + "(see {", + "nonces}" + ], + [ + "TransferToZeroAddress", + "();\\n\\n _beforeTokenTransfers(from, to, tokenId, 1" + ], + [ + "BalanceQueryForZeroAddress", + "();\\n return " + ], + [ + "values(", + "set._inner" + ], + [ + "quantity > ", + "1." + ], + [ + "string memory baseURI = _baseURI();\\n return bytes(baseURI).length", + " != " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev ", + "Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\"" + ], + [ + "TOTAL", + "_SUPPLY" + ], + [ + ");\\n\\n // Clear approvals from the previous owner\\n ", + "_approve(address(0), tokenId);\\n\\n " + ], + [ + "(uint256 tokenId) public view virtual override returns (address) {\\n ", + "address owner = " + ], + [ + "Incenti", + "ve" + ], + [ + "\\n * ", + " " + ], + [ + "Issu", + "ed" + ], + [ + " bits\\n *\\n * ", + "_Available since v3.1._\\n */\\n function toInt" + ], + [ + ") public virtual override returns (bool) {\\n address spender = _msgSender();\\n _spendAllowance(from, spender, amount);\\n _transfer(from, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, allowance(owner, spender) + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n uint256 currentAllowance = allowance(owner, spender);\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - subtractedValue);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves `amount` of tokens from `from` to `to`.\\n *\\n * This internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n */\\n function _transfer", + "(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {\\n require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(to != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, amount);\\n\\n uint256 fromBalance = _balances[from];\\n require(fromBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n unchecked {\\n _balances[from] = fromBalance - amount" + ], + [ + "the signature ", + "must use ``owner``'s current nonce " + ], + [ + "_transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) public virtual override {\\n ", + "safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function " + ], + [ + "Return the entire set in an array\\n *\\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block", + ".\\n */\\n function values(" + ], + [ + "result += 1", + ";\\n }\\n return result" + ], + [ + "More ", + "complex " + ], + [ + "TYP", + "E_HASH" + ], + [ + ");\\n // ", + "Reentrancy protection" + ], + [ + "(\\n uint256 a,\\n uint256 b,\\n string memory errorMessage\\n ", + ") internal pure returns (uint256) {\\n unchecked {\\n " + ], + [ + "ER_B", + "OUND" + ], + [ + "].add(addedValue", + ")" + ], + [ + "} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(", + "ERC721.ownerOf(tokenId), to, tokenId" + ], + [ + "isTxLimit", + "Exempt" + ], + [ + "(\\n address sender,\\n address recipient,\\n uint256 ", + "amount\\n ) external returns (bool" + ], + [ + "approve from ", + "non-zero to non-zero " + ], + [ + "address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId", + ") internal view virtual returns (bool) {\\n " + ], + [ + "2098 ", + "short " + ], + [ + "receiver` cannot be the zero address.\\n * - `", + "feeNumerator` cannot be greater than the fee denominator" + ], + [ + "_balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf", + "(uint256 tokenId) public view virtual override returns (address) {\\n address owner = " + ], + [ + ");\\n\\n // Overflow not possible, as _burnCounter cannot be exceed _currentIndex ", + "times.\\n unchecked {\\n " + ], + [ + "https://eips.ethereum.org/EIPS/eip-2612#specification", + "[relevant " + ], + [ + "if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken", + "();\\n\\n " + ], + [ + "v`, `r` and `s` must be a valid ", + "`secp256k1` signature from " + ], + [ + "number is not a perfect square, the value is ", + "rounded down" + ], + [ + "declared to support ERC165 detection", + ".\\n */\\ninterface " + ], + [ + "_currentIndex;\\n\\n // The ", + "number of tokens burned" + ], + [ + "} else {\\n assembly {\\n ", + "revert(add(32, reason), mload(reason))\\n }\\n }\\n " + ], + [ + "Zero // Toward ", + "zero" + ], + [ + "the signature must use ``owner``'s current nonce ", + "(see {nonces}" + ], + [ + "approve from non-zero to non-zero ", + "allowance" + ], + [ + "https://eips.ethereum.org/EIPS/eip-2612#specification[relevant ", + "EIP" + ], + [ + ")", + ") public " + ], + [ + ".", + "\\r\\n " + ], + [ + ";", + "`" + ], + [ + "C", + "ool" + ], + [ + "P", + "si" + ], + [ + "U", + "D" + ], + [ + "W", + "AD" + ], + [ + "_", + "limit" + ], + [ + "_", + "useNonce" + ], + [ + "`", + "\\n *" + ], + [ + "b", + "oost" + ], + [ + "f", + "d" + ], + [ + "f", + "il" + ], + [ + "g", + "ing " + ], + [ + "h", + "ar" + ], + [ + "k", + "=" + ], + [ + "u", + "gs" + ], + [ + "\\n ", + "/**\\n * @dev " + ], + [ + "re", + "p" + ], + [ + "re", + "s " + ], + [ + "s ", + "per " + ], + [ + "on", + "JoinPool" + ], + [ + "\\n ", + "unchecked {\\n return _currentIndex - " + ], + [ + "th", + "rows " + ], + [ + ", ", + "for " + ], + [ + "t ", + "Cond" + ], + [ + "the ", + "user " + ], + [ + "at", + "t Cond" + ], + [ + "token", + "Count" + ], + [ + "ar", + "ch" + ], + [ + "\\r", + "\\n // " + ], + [ + "to ", + "track the " + ], + [ + "` ", + "with `" + ], + [ + "` ", + "array " + ], + [ + "/**", + " " + ], + [ + ": ", + "interaction" + ], + [ + ": ", + "see https://github.com/ethereum/solidity/issues/" + ], + [ + "or ", + "counting " + ], + [ + "\\n * ", + "control " + ], + [ + "\\n * ", + "tokens and those that they have an allowance for, in a way that can " + ], + [ + "\\n * ", + "of the private keys of a given address" + ], + [ + " = ", + "keccak256(\\n " + ], + [ + ",\\n ", + "int256 " + ], + [ + "in ", + "term" + ], + [ + "In", + "c" + ], + [ + "total", + "Fees" + ], + [ + ";\\n ", + "_currentIndex = _startTokenId" + ], + [ + "recipient", + " " + ], + [ + "current", + "(Counter storage counter" + ], + [ + "on ", + "(@" + ], + [ + ");\\n\\n ", + "_" + ], + [ + ";\\n\\n ", + "bytes32 public constant " + ], + [ + "bytes32 ", + "constant " + ], + [ + "role", + "-based " + ], + [ + "IP", + "ro" + ], + [ + "// S", + "tore the " + ], + [ + "On", + "Buy" + ], + [ + "uint8", + "0" + ], + [ + "\"// SPDX-License-Identifier: MIT", + "\\n\\npragma solidity ^" + ], + [ + "\\n * @dev ", + "Provides " + ], + [ + ":= ", + "keccak256(0x" + ], + [ + ") private ", + "{\\n require(" + ], + [ + ". This ", + "can be used " + ], + [ + "+= ", + "1;\\n " + ], + [ + "emp", + "orari" + ], + [ + "Buy", + "er" + ], + [ + "used ", + "with " + ], + [ + "_max", + "Supply" + ], + [ + "_value", + "; // " + ], + [ + "has ", + "related to " + ], + [ + "128", + "\\n " + ], + [ + "(tokenId", + "))" + ], + [ + "out", + "-of-" + ], + [ + ", bool ", + "approvalCheck" + ], + [ + "previous", + "Admin" + ], + [ + "()", + "), " + ], + [ + "ach", + "ieve " + ], + [ + "() ", + "!= " + ], + [ + "Solidity ", + "v0.5." + ], + [ + "library", + ": interaction" + ], + [ + "default", + ": 0" + ], + [ + "MAX", + "_B" + ], + [ + "prevent", + "s a " + ], + [ + "also ", + "apply " + ], + [ + "36", + " " + ], + [ + "s that ", + "can only be " + ], + [ + "Team", + "Fee" + ], + [ + "{IERC20-", + "approve" + ], + [ + "\"contracts/", + "pendle" + ], + [ + "\\\");\\n return ", + "_balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = " + ], + [ + "you ", + "want to " + ], + [ + "s.\\n *\\n * ", + "These functions can be used to verify that a message was signed by the holder" + ], + [ + "e.g. ", + "to track the " + ], + [ + "ERC721 ", + "ids, " + ], + [ + "ed, ", + "though " + ], + [ + ";\\r\\n ", + "address public " + ], + [ + "Set storage set", + ") private view returns (" + ], + [ + "counter", + "s that can only be " + ], + [ + "gi", + "ves the " + ], + [ + "with `", + "using Counters for Counters.Counter" + ], + [ + "46", + "37" + ], + [ + "_ownership", + "Of(uint256 tokenId" + ], + [ + ");\\n ", + "event " + ], + [ + "minter", + "_" + ], + [ + "\"@openzeppelin/contracts/utils/", + "math/Math.sol\"" + ], + [ + "manag", + "er" + ], + [ + "s of the ", + "library: interaction" + ], + [ + "_add", + "Minter" + ], + [ + "provid", + "ed, " + ], + [ + "s. ", + "Each " + ], + [ + "OperatorFilterer", + " {\\n " + ], + [ + "element", + "s in a " + ], + [ + "shr", + "ugs" + ], + [ + "(owner", + "(), " + ], + [ + "RoyaltyInfo", + "(receiver, feeNumerator" + ], + [ + " = 0x", + "00" + ], + [ + "block ", + "number " + ], + [ + "Power", + "Perp" + ], + [ + "))\\n ", + "}\\n\\n // " + ], + [ + "_init", + "(" + ], + [ + "perform ", + "a " + ], + [ + "ln", + "(" + ], + [ + "2, ", + "this cannot be " + ], + [ + "feeNumerator", + " <= _" + ], + [ + ";\\n }\\n\\n ", + "uint256 " + ], + [ + "counter._", + "value " + ], + [ + "from the caller's\\n * allowance", + ".\\n *\\n * See {ERC20-_burn} and {ERC20-allowance}.\\n *\\n * Requirements:\\n *\\n * - the caller must have allowance for " + ], + [ + "(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n ", + "if (b == 0) return (false, 0);\\n return (true, " + ], + [ + "Get", + "s the " + ], + [ + "reser", + "ved " + ], + [ + "((((", + "((((" + ], + [ + "proposal", + " to add" + ], + [ + "additionalPayee", + "PrimarySales" + ], + [ + "staking", + "Token" + ], + [ + "();", + " " + ], + [ + "] != ", + "0" + ], + [ + "(), \\\"", + "ERC2981: royalty fee will exceed salePrice" + ], + [ + "enforc", + "ed, though " + ], + [ + ") {\\n bytes32 ", + "computedHash = leaf" + ], + [ + "_checkContractOnERC721Received", + "(from, to, tokenId, _data" + ], + [ + "feeDenominator", + "(), \\\"ERC2981: royalty fee will exceed salePrice" + ], + [ + ", pre", + "v" + ], + [ + "Input", + "Helper" + ], + [ + "updateSwap", + "Enabled" + ], + [ + "request ", + "id" + ], + [ + "lim", + "it is " + ], + [ + "------------", + "---" + ], + [ + "Gobbl", + "er" + ], + [ + "zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general ", + "OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 " + ], + [ + "successful ", + "call to " + ], + [ + "\\\"}", + ",{\\\"" + ], + [ + "feature", + ": see https://github.com/ethereum/solidity/issues/" + ], + [ + ";\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to ", + "owner address" + ], + [ + "Multiple", + "Accounts" + ], + [ + "Deposi", + "t " + ], + [ + "As of ", + "Solidity v0.5." + ], + [ + "https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522", + "\\n if (a " + ], + [ + "ordering ", + "also apply " + ], + [ + "revert TransferToNonERC721ReceiverImplementer();\\n ", + "} else {\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n " + ], + [ + ".\\n // See: ", + "https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a " + ], + [ + "_tokenRoyaltyInfo", + "[tokenId" + ], + [ + ". This includes minting.\\n * And also called ", + "before burning one token" + ], + [ + "Sol", + "mate " + ], + [ + ", \\\"!auth", + "\\\");\\n " + ], + [ + "s must be ", + "restricted " + ], + [ + " of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative", + ").\\n *\\n * " + ], + [ + "OpenZeppelin Contracts guidelines: functions revert\\n * instead returning `false` on failure. This behavior is nonetheless\\n * conventional and does not conflict with the expectations of ERC20\\n * applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping(address => uint256) private _balances;\\n\\n mapping(address => mapping(address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The default value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5.05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address to, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _transfer(owner, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``from``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 amount\\n ", + ") public virtual override returns (bool) {\\n address spender = _msgSender();\\n _spendAllowance(from, spender, amount);\\n _transfer(from, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, allowance(owner, spender) + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n uint256 currentAllowance = allowance(owner, spender);\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - subtractedValue);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves `amount` of tokens from `from` to `to`.\\n *\\n * This internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {\\n require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(to != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, amount);\\n\\n uint256 fromBalance = _balances[from];\\n require(fromBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n unchecked {\\n _balances[from] = fromBalance - amount" + ], + [ + "resc", + "ue" + ], + [ + "there is a ", + "proposal to add" + ], + [ + "_TH", + "IS" + ], + [ + "about to be transferred", + ". This includes minting.\\n * And also called before burning one token" + ], + [ + "token that ", + "is not " + ], + [ + "ed by user", + "s of the library: interaction" + ], + [ + "provenance ", + "hash" + ], + [ + "directly access", + "ed by users of the library: interaction" + ], + [ + ";\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n ", + "revert(\\\"ERC721: transfer to non ERC721Receiver implementer" + ], + [ + "Pc", + "t" + ], + [ + "currOwnershipAddr = ", + "ownership.addr" + ], + [ + "function. ", + "As of Solidity v0.5." + ], + [ + "667", + "c8" + ], + [ + ") return (false, 0);\\n return (true, c", + ");\\n }\\n\\n /**\\n * @dev Returns the " + ], + [ + ";\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n ", + "revert TransferToNonERC721ReceiverImplementer();\\n } else {\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n " + ], + [ + "mapping, ", + "issuing " + ], + [ + "\\n * @author M", + "att Cond" + ], + [ + "Include ", + "with `using Counters for Counters.Counter" + ], + [ + "\\\");\\n return owner", + ";\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (" + ], + [ + "Elliptic Curve Digital Signature Algorithm (ECDSA) operation", + "s.\\n *\\n * These functions can be used to verify that a message was signed by the holder" + ], + [ + "The same ", + "issues " + ], + [ + "This variable ", + "should never be " + ], + [ + "library's ", + "function. As of Solidity v0.5." + ], + [ + "or counting ", + "request id" + ], + [ + "\\n * tokens and those that they have an allowance for, in a way that can ", + "be\\n * re" + ], + [ + "on (@", + "shrugs" + ], + [ + "\\n * @dev Provides ", + "counters that can only be " + ], + [ + ". This can be used ", + "e.g. to track the " + ], + [ + "_value; // ", + "default: 0" + ], + [ + "has related to ", + "transaction" + ], + [ + "ERC721 ids, ", + "or counting request id" + ], + [ + "elements in a ", + "mapping, issuing " + ], + [ + "2, this cannot be ", + "enforced, though " + ], + [ + "feeNumerator <= _", + "feeDenominator(), \\\"ERC2981: royalty fee will exceed salePrice" + ], + [ + "feature: see https://github.com/ethereum/solidity/issues/", + "4637" + ], + [ + "ordering also apply ", + "here" + ], + [ + "directly accessed by users of the library: interaction", + "s must be restricted " + ], + [ + ";\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer", + "\\\");\\n } else {\\n " + ], + [ + "\\n * @author Matt Cond", + "on (@shrugs" + ], + [ + "Include with `using Counters for Counters.Counter", + ";`" + ], + [ + "Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\\n *\\n * These functions can be used to verify that a message was signed by the holder", + "\\n * of the private keys of a given address" + ], + [ + "This variable should never be ", + "directly accessed by users of the library: interactions must be restricted " + ], + [ + "library's function. As of Solidity v0.5.", + "2, this cannot be enforced, though " + ], + [ + "\\n * @dev Provides counters that can only be ", + "increment" + ], + [ + ". This can be used e.g. to track the ", + "number" + ], + [ + "elements in a mapping, issuing ", + "ERC721 ids, or counting request id" + ], + [ + "\\n * @author Matt Condon (@shrugs", + ")" + ], + [ + "library's function. As of Solidity v0.5.2, this cannot be enforced, though ", + "there is a proposal to add" + ], + [ + "\"", + "Pausable: " + ], + [ + "B", + "C" + ], + [ + "F", + "L" + ], + [ + "I", + "Factory" + ], + [ + "M", + "arketing " + ], + [ + "P", + "ending " + ], + [ + "P", + "UT" + ], + [ + "W", + "all" + ], + [ + "]", + ";\\n " + ], + [ + "_", + "G" + ], + [ + "_", + "frequencyInSeconds" + ], + [ + "a", + "in the " + ], + [ + "b", + "c" + ], + [ + "\\n ", + "address public " + ], + [ + "re", + "initializer" + ], + [ + "int", + "64" + ], + [ + "on", + "ExitPool" + ], + [ + "\\n ", + "address signer = ecrecover(hash, v, r, s" + ], + [ + ", ", + "ERC721A" + ], + [ + ", ", + "i.e. " + ], + [ + "\\n * ", + "section" + ], + [ + "or", + "ing" + ], + [ + ") ", + "- " + ], + [ + ") ", + "and " + ], + [ + "address", + ") {\\r\\n return " + ], + [ + "ic", + "sa" + ], + [ + "amount", + "s.length" + ], + [ + "20", + "76" + ], + [ + "20", + "a3c" + ], + [ + "ma", + "ke" + ], + [ + "\\n * ", + "in bugs, because programmers usually assume that an overflow raises " + ], + [ + ") internal ", + "{\\r\\n " + ], + [ + "data", + "[" + ], + [ + "} ", + "is\\n * " + ], + [ + "} ", + "has related to transaction" + ], + [ + "new", + "Max" + ], + [ + "\\n * - ", + "the signature must use ``owner``'s current nonce (see {nonces}" + ], + [ + "Su", + "per" + ], + [ + "by ", + "one. " + ], + [ + "bytes32", + "(uint256(" + ], + [ + "string", + ".\\n */\\n function " + ], + [ + ", uint256 ", + "required" + ], + [ + "token ", + "transfer to " + ], + [ + ";\\n", + "\\n if (" + ], + [ + "num", + " * " + ], + [ + "tokens ", + "were " + ], + [ + "cc", + "37" + ], + [ + "(\\n ", + "Swap" + ], + [ + "IN", + " " + ], + [ + "With", + "Fallback" + ], + [ + ",\\n uint256 ", + "protocolSwapFeePercentage" + ], + [ + "\\n // ", + "these malleable signatures as well" + ], + [ + "\\n // ", + "with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or" + ], + [ + "\\n // ", + "signatures from current libraries generate a unique signature with an s-value in the lower half order" + ], + [ + "\\n // ", + "vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept" + ], + [ + "\\n // ", + "unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines" + ], + [ + "\\n }\\n\\n function ", + "current(Counter storage counter" + ], + [ + "pl", + "et" + ], + [ + "buy", + "Tax" + ], + [ + ";\\n ", + "assembly {\\n // " + ], + [ + "``", + "\\u0027s " + ], + [ + "deleg", + "ation " + ], + [ + "amount ", + "> 0, \\\"" + ], + [ + "Hash", + "(" + ], + [ + "0 ", + "+ " + ], + [ + "Pool", + "Balance" + ], + [ + "__", + " " + ], + [ + "KK", + "K" + ], + [ + " {\\n ", + "/**\\n * " + ], + [ + "`account", + "`)" + ], + [ + ";\\n }\\n\\n function ", + "increment" + ], + [ + "St", + "at" + ], + [ + "sum", + " += " + ], + [ + ").\\n *\\n * ", + "For more information on the signature format, see " + ], + [ + "the\\n * ", + "https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP" + ], + [ + ";\\n ", + "uint256 " + ], + [ + "startTokenId", + "() <= " + ], + [ + "}\\n }\\n\\n /**\\n * @dev ", + "Hook that is called before " + ], + [ + "sub(", + "a, b" + ], + [ + "auth", + "ent" + ], + [ + "(from, to, tokenId", + ");\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n " + ], + [ + ") internal virtual {\\n require(", + "ERC721.ownerOf(tokenId) == from, \\\"ERC721: " + ], + [ + "royal", + "ti" + ], + [ + "||", + "||" + ], + [ + "s.\\n *\\n * ", + "Include with `using Counters for Counters.Counter;`" + ], + [ + "35", + "a9" + ], + [ + "self", + "._" + ], + [ + "leaf", + ") == root" + ], + [ + "refer", + "red to " + ], + [ + "through ", + "the " + ], + [ + ") {\\n // ", + "32 is the length in bytes of hash" + ], + [ + "Counter ", + "{\\n // " + ], + [ + "48", + ", " + ], + [ + "Acc", + "umul" + ], + [ + "(\\n uint256 ", + "tokenId" + ], + [ + "curr", + " < _" + ], + [ + "Sh", + "are " + ], + [ + "5d", + "38" + ], + [ + "\\n uint256 ", + "_value; // default: 0" + ], + [ + "Com", + "pos" + ], + [ + ") + ", + "1)" + ], + [ + ".\\n * ", + "`SafeMath` restores this intuition by reverting the transaction when " + ], + [ + "decrement", + "(Counter storage counter) internal {\\n " + ], + [ + "sent", + "inel" + ], + [ + "API", + " and " + ], + [ + "clusi", + "on" + ], + [ + "da", + "ting" + ], + [ + "too ", + "big" + ], + [ + "delegator", + "Balance" + ], + [ + "alloc", + "ate" + ], + [ + "`.\\n *\\n * This ", + "is " + ], + [ + ") internal view returns (uint256) {\\n return ", + "counter._value" + ], + [ + "nonce ", + "by one. " + ], + [ + "92", + "db" + ], + [ + "Cle", + "ar" + ], + [ + ".\\n */\\nlibrary ", + "ECDSA" + ], + [ + "Counters", + "\\n * @author Matt Condon (@shrugs)" + ], + [ + "restrict ", + "access to " + ], + [ + ",\\n // ", + "enforced by the type signature above" + ], + [ + "voting", + "P" + ], + [ + "for `owner", + "`. This value " + ], + [ + "spender` cannot be the zero address.\\n * - `", + "deadline` must be a timestamp in the future" + ], + [ + "`. This ", + "address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it" + ], + [ + "\\n // the ", + "valid range for s in " + ], + [ + "cons", + "ist" + ], + [ + "ba", + "1a" + ], + [ + "period", + "Finish" + ], + [ + "94", + "a13" + ], + [ + "due ", + "to the " + ], + [ + ") public override ", + "returns (bool) {\\n " + ], + [ + "_approve(_msgSender(), spender, ", + "currentAllowance " + ], + [ + "_user", + "s" + ], + [ + "ages", + ".\\n * `SafeMath` restores this intuition by reverting the transaction when " + ], + [ + "fa", + "v" + ], + [ + "address owner = ERC721.ownerOf(tokenId", + ");\\n return (spender == owner || " + ], + [ + "signature is ", + "generated " + ], + [ + "(from, address(0), tokenId", + ");\\n _afterTokenTransfers" + ], + [ + "emergen", + "cy" + ], + [ + "Move the ", + "pointer " + ], + [ + "access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _transferOwnership(_msgSender()", + ");\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\"" + ], + [ + "swapAndLiquify", + "Enabled" + ], + [ + "{permit} ", + "increases " + ], + [ + "Fir", + "st " + ], + [ + "3e", + "2076" + ], + [ + "an\\n * ", + "error, which is the standard behavior in high level programming langu" + ], + [ + ".\\n //\\n // ", + "If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value" + ], + [ + "\\n * of ", + "elements in a mapping, issuing ERC721 ids, or counting request id" + ], + [ + ") internal pure returns (bytes32", + ") {\\n bytes32 computedHash = leaf" + ], + [ + "signature from ", + "being used " + ], + [ + ", created from ", + "a\\n * `" + ], + [ + "Extra ", + "data " + ], + [ + "ca", + "3e2076" + ], + [ + ").transfer", + "(" + ], + [ + "is not active", + ".\"" + ], + [ + "(address(0), to, tokenId", + ");\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n " + ], + [ + "(proof, ", + "leaf) == root" + ], + [ + "address that signed a hashed message (`hash`) with\\n * `signature", + "`. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it" + ], + [ + ")\\n }\\n return ", + "size > 0" + ], + [ + "or equal", + " to " + ], + [ + "01ffc9a7", + " || " + ], + [ + "Library for ", + "manag" + ], + [ + ";\\n for (uint256 i = 0; i < ", + "proof.length; i++) {\\n " + ], + [ + "\\n * @title", + " " + ], + [ + "(address registrant, address registrant", + "ToCopy" + ], + [ + "their", + " `" + ], + [ + "Alp", + "ha" + ], + [ + "s with added overflow\\n * checks.\\n *\\n * ", + "Arithmetic operations in Solidity wrap on overflow. This can easily result" + ], + [ + "(sender, recipient, amount);\\n ", + "_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, \\\"ERC20: transfer amount exceeds allowance\\\")" + ], + [ + "included ", + "whenever a " + ], + [ + "a50", + "5d38" + ], + [ + "\\\");\\n\\n require(\\n ", + "_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: " + ], + [ + "Destroys `amount` tokens from the caller", + ".\\n *\\n * See {ERC20-_burn}.\\n */\\n function burn(uint256 amount) public virtual {\\n _burn(_msgSender(), amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, deducting " + ], + [ + "tokens,\\n * ", + "given " + ], + [ + "to == address(0)) revert ", + "TransferToZeroAddress();\\n\\n _beforeTokenTransfers(from, to, tokenId, 1" + ], + [ + ", bytes32 leaf", + ") internal pure returns (bytes32) {\\n bytes32 computedHash = leaf" + ], + [ + "284", + "92db" + ], + [ + "\\n // this ", + "feature: see https://github.com/ethereum/solidity/issues/4637" + ], + [ + "`owner`\\n * ", + "over the EIP712-formatted function arguments." + ], + [ + "Extension of {ERC20} that allows token holders to destroy both their own", + "\\n * tokens and those that they have an allowance for, in a way that can be\\n * re" + ], + [ + "twos := add(div(sub(0, twos), twos), ", + "1" + ], + [ + "2bb", + "c" + ], + [ + "to\\n // the ", + "library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add" + ], + [ + "3210", + "667c8" + ], + [ + "98d", + "ca3e2076" + ], + [ + "If the signature is valid (and not malleable), return the signer address", + "\\n address signer = ecrecover(hash, v, r, s" + ], + [ + "EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature", + "\\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines" + ], + [ + "Every ", + "successful call to " + ], + [ + "from) revert ", + "TransferFromIncorrectOwner" + ], + [ + "twitter", + ".com/" + ], + [ + "++, _data", + ")) {\\n " + ], + [ + "string memory) {\\n if (!_exists(tokenId)) revert URIQueryForNonexistentToken();\\n\\n ", + "string memory baseURI = _baseURI();\\n return bytes(baseURI).length != " + ], + [ + "2): v ∈ {27, 28}. Most", + "\\n // signatures from current libraries generate a unique signature with an s-value in the lower half order" + ], + [ + "3608", + "94a13" + ], + [ + "revert TransferToNonERC721ReceiverImplementer();", + "\\n }\\n } while (" + ], + [ + ");\\n\\n // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.\\n unchecked {\\n ", + "_burnCounter++" + ], + [ + "declared to support ERC165 detection.\\n */\\ninterface ", + "IAccessControl" + ], + [ + "emporari", + "ly" + ], + [ + "prevents a ", + "signature from being used " + ], + [ + "{IERC20-approve", + "} has related to transaction" + ], + [ + "MultipleAccounts", + "FromFees" + ], + [ + "token that is not ", + "own" + ], + [ + "The same issues ", + "{IERC20-approve} has related to transaction" + ], + [ + "Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\\n *\\n * These functions can be used to verify that a message was signed by the holder\\n * of the private keys of a given address", + ".\\n */\\nlibrary ECDSA" + ], + [ + "This variable should never be directly accessed by users of the library: interactions must be restricted ", + "to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add" + ], + [ + ". This can be used e.g. to track the number", + "\\n * of elements in a mapping, issuing ERC721 ids, or counting request id" + ], + [ + "\\n * section", + "].\\n */\\n function " + ], + [ + "20a3c", + "a505d38" + ], + [ + "\\n * in bugs, because programmers usually assume that an overflow raises ", + "an\\n * error, which is the standard behavior in high level programming langu" + ], + [ + "\\n * - the signature must use ``owner``'s current nonce (see {nonces}", + ").\\n *\\n * For more information on the signature format, see " + ], + [ + "cc37", + "35a9" + ], + [ + "\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or", + "\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept" + ], + [ + "\\n }\\n\\n function current(Counter storage counter", + ") internal view returns (uint256) {\\n return counter._value" + ], + [ + ";\\n }\\n\\n function increment", + "(Counter storage counter) internal {\\n " + ], + [ + "the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP", + "\\n * section].\\n */\\n function " + ], + [ + "startTokenId() <= ", + "tokenId " + ], + [ + ") {\\n // 32 is the length in bytes of hash", + ",\\n // enforced by the type signature above" + ], + [ + "Counter {\\n // ", + "This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add" + ], + [ + "curr < _", + "currentIndex" + ], + [ + "\\n uint256 _value; // default: 0", + "\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value" + ], + [ + "Counters\\n * @author Matt Condon (@shrugs)", + "\\n * @dev Provides counters that can only be increment" + ], + [ + "spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future", + ".\\n * - `" + ], + [ + "ba1a", + "3210667c8" + ], + [ + "ages.\\n * `SafeMath` restores this intuition by reverting the transaction when ", + "an\\n * " + ], + [ + "signature is generated ", + "for {permit" + ], + [ + "(from, address(0), tokenId);\\n _afterTokenTransfers", + "(from, address(0), tokenId, 1" + ], + [ + ".\\n //\\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value", + "\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept" + ], + [ + "s with added overflow\\n * checks.\\n *\\n * Arithmetic operations in Solidity wrap on overflow. This can easily result", + "\\n * in bugs, because programmers usually assume that an overflow raises an\\n * error, which is the standard behavior in high level programming langu" + ], + [ + "included whenever a ", + "signature is generated for {permit" + ], + [ + ", bytes32 leaf) internal pure returns (bytes32) {\\n bytes32 computedHash = leaf", + ";\\n for (uint256 i = 0; i < proof.length; i++) {\\n " + ], + [ + "28492db", + "98dca3e2076" + ], + [ + "\\n // this feature: see https://github.com/ethereum/solidity/issues/4637", + "\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value" + ], + [ + "`owner`\\n * over the EIP712-formatted function arguments.", + "\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see " + ], + [ + "Extension of {ERC20} that allows token holders to destroy both their own\\n * tokens and those that they have an allowance for, in a way that can be\\n * re", + "cognized off-chain (via event analysis)." + ], + [ + "EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines", + "\\n // the valid range for s in " + ], + [ + "Every successful call to ", + "{permit} increases " + ], + [ + "2): v ∈ {27, 28}. Most\\n // signatures from current libraries generate a unique signature with an s-value in the lower half order", + ".\\n //\\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept" + ], + [ + "360894a13", + "ba1a3210667c8" + ], + [ + "prevents a signature from being used ", + "multiple times" + ], + [ + ". This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request id", + "s.\\n *\\n * Include with `using Counters for Counters.Counter;`" + ], + [ + "20a3ca505d38", + "2bbc" + ], + [ + "cc3735a9", + "20a3ca505d382bbc" + ], + [ + "Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add", + "\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value" + ], + [ + "s with added overflow\\n * checks.\\n *\\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\\n * in bugs, because programmers usually assume that an overflow raises an\\n * error, which is the standard behavior in high level programming langu", + "ages.\\n * `SafeMath` restores this intuition by reverting the transaction when an\\n * " + ], + [ + "28492db98dca3e2076", + "cc3735a920a3ca505d382bbc" + ], + [ + "`owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see ", + "the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function " + ], + [ + "2): v ∈ {27, 28}. Most\\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\\n //\\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept", + "\\n // these malleable signatures as well" + ], + [ + "360894a13ba1a3210667c8", + "28492db98dca3e2076cc3735a920a3ca505d382bbc" + ], + [ + "Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value", + ";\\n }\\n\\n function increment(Counter storage counter) internal {\\n " + ], + [ + "#", + "%" + ], + [ + "'", + "0" + ], + [ + ")", + "\\n */\\n function " + ], + [ + ")", + "{\\n " + ], + [ + ")", + "`. This value " + ], + [ + ".", + "\\\");\\n " + ], + [ + ".", + "json" + ], + [ + "/", + "api/" + ], + [ + "P", + "U" + ], + [ + "S", + "ource" + ], + [ + "_", + "team" + ], + [ + "`", + "2**" + ], + [ + "b", + "6" + ], + [ + "c", + "ause" + ], + [ + "e", + "8" + ], + [ + "e", + "ˆ" + ], + [ + "e", + "gr" + ], + [ + "k", + "+1)" + ], + [ + "m", + "alici" + ], + [ + "v", + "1." + ], + [ + "z", + "^" + ], + [ + "{", + "revokeRole" + ], + [ + "\\n ", + ");\\n }\\n\\n function " + ], + [ + "in", + "centi" + ], + [ + ", ", + "2" + ], + [ + ", ", + "f" + ], + [ + ", ", + "an " + ], + [ + ", ", + "uint16 _" + ], + [ + "uint256", + "[" + ], + [ + "a ", + "? 1 : 0" + ], + [ + "` ", + "function " + ], + [ + "Ow", + "ed" + ], + [ + "acc", + "Log" + ], + [ + "ma", + "tur" + ], + [ + "if", + "ication " + ], + [ + "Transfer", + "Delay" + ], + [ + "balance", + "Before" + ], + [ + "token ", + "list" + ], + [ + "token ", + "supply " + ], + [ + "This ", + "can be re" + ], + [ + "num", + " / " + ], + [ + "num", + " = (" + ], + [ + "atu", + "r" + ], + [ + ");\\n\\n ", + "address from" + ], + [ + "symbol", + "s needed to " + ], + [ + "this ", + "role " + ], + [ + "\\r\\n ", + "//" + ], + [ + ").", + "\\n // " + ], + [ + " ", + " " + ], + [ + "eth", + "-" + ], + [ + "pay", + "out " + ], + [ + "bytes32 ", + "adminRole" + ], + [ + "bytes32 ", + "structHash" + ], + [ + "// S", + "tart " + ], + [ + "{\\n ", + "event " + ], + [ + "\"// SPDX-License-Identifier: ", + "UNLICENSED" + ], + [ + ",\\n address ", + "receiver" + ], + [ + "._", + "\\r\\n */\\r\\n function " + ], + [ + "result ", + "gives the " + ], + [ + "Per", + "m" + ], + [ + "Per", + "iod " + ], + [ + "_approve", + "(msg.sender, " + ], + [ + "overflow", + "s " + ], + [ + "Min", + ",\\r\\n address to,\\r\\n uint deadline" + ], + [ + "data ", + "(" + ], + [ + "amount ", + "> " + ], + [ + "can be ", + "written " + ], + [ + ") internal virtual ", + "override " + ], + [ + "point", + "er to " + ], + [ + "\\\\", + "|" + ], + [ + ")\\n ", + "only" + ], + [ + "int256", + " _" + ], + [ + "_S", + "ALE" + ], + [ + "Buy", + "back" + ], + [ + "grant", + " and " + ], + [ + "Con", + "sequently" + ], + [ + ".\\n ", + "require(" + ], + [ + "_token", + "State" + ], + [ + "; // ", + "eˆ" + ], + [ + "string,", + "uint256," + ], + [ + "\\\");\\n require(", + "receiver != address(0), \\\"" + ], + [ + "sol", + "ut" + ], + [ + ") internal virtual {\\n ", + "delete " + ], + [ + ") internal virtual {\\n ", + "_burn(tokenId, false" + ], + [ + "represent", + " `value" + ], + [ + "Add", + "ing one " + ], + [ + "Solidity ", + "0.8" + ], + [ + "first ", + "4" + ], + [ + "first ", + "approxim" + ], + [ + "\\n ) external ", + "onlyOwner {\\n " + ], + [ + "ECDSA", + " signature " + ], + [ + "((", + "k+1)" + ], + [ + "(a", + " * " + ], + [ + "2**", + "((k+1)" + ], + [ + "to the ", + "result gives the " + ], + [ + "Claim", + "able" + ], + [ + "s of ", + "hex " + ], + [ + "_F", + "EE" + ], + [ + "_maxWallet", + "Amount" + ], + [ + ".sol\\\";\\nimport \\\"../../", + "utils/Strings" + ], + [ + "_B", + "AL" + ], + [ + "minting ", + "and burning" + ], + [ + "tick", + " " + ], + [ + "case ", + "0 " + ], + [ + " + 1", + ")`" + ], + [ + "uint256 result = ", + "1 << (" + ], + [ + "(address registrant", + ", bytes32 " + ], + [ + "uri", + "Suffix" + ], + [ + "ene", + "fici" + ], + [ + "DEFAULT_ADMIN_ROLE", + " = 0x00" + ], + [ + "` as a ", + "hex " + ], + [ + ") <= ", + "2**(k/2" + ], + [ + "/2", + ") <= 2**(k/2" + ], + [ + ",\\n bool ", + "approved" + ], + [ + ") private {\\n ", + "uint256 " + ], + [ + "2, ", + "following the selected rounding direction" + ], + [ + ");\\n\\n ", + "/**\\n * @dev " + ], + [ + "need", + "ed" + ], + [ + "(to, tokenId", + ");\\n require(\\n _checkOnERC721Received" + ], + [ + "s is ", + "`" + ], + [ + "string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_", + ";\\n _currentIndex = _startTokenId" + ], + [ + "log2(a", + ") <= a < " + ], + [ + "log2(a", + ")`." + ], + [ + "log2(a", + ") >> 1" + ], + [ + "est way to ", + "achieve " + ], + [ + ".\\n if (", + "address(" + ], + [ + "ERC1967", + ": " + ], + [ + "internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer", + "} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer" + ], + [ + "\\n // @param _", + "src" + ], + [ + "At ", + "the " + ], + [ + ") < ", + "value ? 1 : 0" + ], + [ + "design", + "ed to be " + ], + [ + "2**(k", + "+1" + ], + [ + ") / 2", + ")` is " + ], + [ + "2d", + "cc" + ], + [ + "ckpt", + "s" + ], + [ + "automatedMarketMakerPairs[", + "to" + ], + [ + "written ", + "`2**" + ], + [ + "int256 constant ", + "x" + ], + [ + "sqrt(", + "2**k" + ], + [ + "sqrt(", + "2**(k+1" + ], + [ + "Overri", + "de " + ], + [ + "TokenApproval", + "Ref" + ], + [ + "force", + "Call" + ], + [ + ", `", + "2**(log2(a" + ], + [ + "token/ERC20/extensions/draft-", + "ERC20Permit" + ], + [ + "exchange", + "Rate" + ], + [ + "2**k", + "` with `" + ], + [ + "`msb(a", + ")=" + ], + [ + "interfaceId == 0x", + "01ffc9a7 || " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId", + ", bool approvalCheck" + ], + [ + "enabl", + "ed " + ], + [ + ") <= sqrt(a) < ", + "sqrt(2**(k+1" + ], + [ + "2**(log2(a", + ") + 1)" + ], + [ + "a good ", + "first approxim" + ], + [ + "\"The ", + "pair cannot be removed from automatedMarketMakerPairs\"" + ], + [ + "Option", + "al " + ], + [ + "return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved", + ") public virtual override {\\n " + ], + [ + "the zero address\\\");\\r\\n\\r\\n ", + "_beforeTokenTransfer" + ], + [ + "\"\\x19", + "\\x01" + ], + [ + "accord", + "ing to " + ], + [ + "t.", + "me/" + ], + [ + ")\\n mstore(", + "add(" + ], + [ + ", \\u0027", + "UniswapV2Router" + ], + [ + "Inter", + "val" + ], + [ + "Moves tokens `amount` from `sender` to `recipient", + "`.\\n *\\n * This is " + ], + [ + "; // 2", + "ˆ" + ], + [ + "ByOwnerOr", + "Governance " + ], + [ + "OUT_OF", + "_BOUND" + ], + [ + "z_squa", + "red" + ], + [ + " ********", + " ********" + ], + [ + "uint256) {\\n if (owner == address(0)) revert ", + "BalanceQueryForZeroAddress();\\n return " + ], + [ + "),\\n \\\"ERC721: transfer to non ERC721Receiver implementer\\\"\\n ", + ");\\n }\\n\\n /**\\n * @dev Mint" + ], + [ + ": r", + "," + ], + [ + "over time.\\n */\\n function ", + "_ownershipOf(uint256 tokenId" + ], + [ + "number of pair", + "s of hex " + ], + [ + "var-name-mixedcase", + "\\n " + ], + [ + "result * result < ", + "a ? 1 : 0" + ], + [ + "square root of a number", + ". If the " + ], + [ + "2**(k/2) <= sqrt(a) < ", + "2**((k+1)" + ], + [ + ").\\n */\\n function _getAux(address owner) internal view returns (uint64", + ") {\\n return " + ], + [ + "`msb(a) <= a < 2*msb(a", + ")`. This value " + ], + [ + ";\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(", + "IERC165" + ], + [ + "receiver` cannot be the zero address.\\n * - `feeNumerator` cannot be greater than the fee denominator", + ".\\n */\\n function _set" + ], + [ + "v`, `r` and `s` must be a valid `secp256k1` signature from ", + "`owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function " + ], + [ + "k=", + "log2(a)`." + ], + [ + "RoyaltyInfo(receiver, feeNumerator", + ");\\n }\\n\\n /**\\n * @dev " + ], + [ + "from the caller's\\n * allowance.\\n *\\n * See {ERC20-_burn} and {ERC20-allowance}.\\n *\\n * Requirements:\\n *\\n * - the caller must have allowance for ", + "``accounts``'s " + ], + [ + "feeNumerator <= _feeDenominator(), \\\"ERC2981: royalty fee will exceed salePrice", + "\\\");\\n require(receiver != address(0), \\\"" + ], + [ + "num * ", + "z_squared" + ], + [ + "sum += ", + "x" + ], + [ + "spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `", + "v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function " + ], + [ + "This can be re", + "written `2**" + ], + [ + "num = (", + "num * z_squared" + ], + [ + "symbols needed to ", + "represent `value" + ], + [ + "can be written ", + "`msb(a)=" + ], + [ + "Consequently", + ", `2**(log2(a" + ], + [ + "; // eˆ", + "(x" + ], + [ + ") internal virtual {\\n _burn(tokenId, false", + ");\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId, bool approvalCheck" + ], + [ + "Adding one ", + "to the result gives the " + ], + [ + "uint256 result = 1 << (", + "log2(a) >> 1" + ], + [ + "/2) <= 2**(k/2", + " + 1)`" + ], + [ + "log2(a) <= a < ", + "2**(log2(a) + 1)" + ], + [ + ") / 2)` is ", + "a good first approxim" + ], + [ + "sqrt(2**k", + ") <= sqrt(a) < sqrt(2**(k+1" + ], + [ + "2**k` with `", + "k=log2(a)`." + ], + [ + "\"\\x19\\x01", + "\"" + ], + [ + "Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is ", + "internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer" + ], + [ + "OUT_OF_BOUND", + "S" + ], + [ + "number of pairs of hex ", + "symbols needed to represent `value" + ], + [ + "2**(k/2) <= sqrt(a) < 2**((k+1)", + "/2) <= 2**(k/2 + 1)`" + ], + [ + "`msb(a) <= a < 2*msb(a)`. This value ", + "can be written `msb(a)=" + ], + [ + "This can be rewritten `2**", + "log2(a) <= a < 2**(log2(a) + 1)" + ], + [ + "Consequently, `2**(log2(a", + ") / 2)` is a good first approxim" + ], + [ + "Adding one to the result gives the ", + "number of pairs of hex symbols needed to represent `value" + ], + [ + "sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1", + "))" + ], + [ + "`msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=", + "2**k` with `k=log2(a)`." + ], + [ + "Consequently, `2**(log2(a) / 2)` is a good first approxim", + "ation of `sqrt(a)` with at least 1 correct bit" + ], + [ + "Adding one to the result gives the number of pairs of hex symbols needed to represent `value", + "` as a hex " + ], + [ + "(", + "address[] calldata " + ], + [ + "H", + "ub" + ], + [ + "W", + "AL" + ], + [ + "_", + "trans" + ], + [ + "`", + "newAdminRole" + ], + [ + "b", + "65" + ], + [ + "e", + "ffic" + ], + [ + "f", + "r" + ], + [ + "p", + "xCvx" + ], + [ + "s", + "s" + ], + [ + "t", + "e " + ], + [ + "╚", + "═╝" + ], + [ + "\\n ", + "uint256 " + ], + [ + "\\n ", + ");\\n\\n " + ], + [ + "s ", + "== " + ], + [ + ", ", + "string " + ], + [ + "256", + ", rounded down" + ], + [ + "\\n * ", + "ordering also apply here" + ], + [ + "token", + "s[" + ], + [ + "ex", + "amples" + ], + [ + "ERC", + "4626" + ], + [ + "To", + "Account" + ], + [ + "To", + "Copy " + ], + [ + "owner", + " != " + ], + [ + ".\\n *\\n * ", + "Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11" + ], + [ + "\\n * ", + "in the " + ], + [ + ".\\n */\\n function ", + "sqrt(uint256 a" + ], + [ + "um", + "p" + ], + [ + "wh", + "at " + ], + [ + "index", + "];\\n }\\n\\n /**\\n * @dev " + ], + [ + "32", + "\\n inverse *= 2 - denominator * inverse; // inverse mod 2^" + ], + [ + "and ", + "is " + ], + [ + "} ", + "not being emitted " + ], + [ + "pro", + "cess " + ], + [ + "by ", + "their `" + ], + [ + "{\\n ", + "Down, // Toward negative " + ], + [ + "cur", + "rency" + ], + [ + "16", + "\\n inverse *= 2 - denominator * inverse; // inverse mod 2^" + ], + [ + "check", + "s on " + ], + [ + "cre", + "ation " + ], + [ + "ce", + "pt" + ], + [ + "sign", + "aling " + ], + [ + "0x", + "8" + ], + [ + "\\n // ", + "is no longer required" + ], + [ + "\\n // ", + "512 by 256 division" + ], + [ + "\\n // ", + "variables such that product = prod1 * 2^256 + prod0." + ], + [ + "\\n // ", + "four bits. That is, denominator * inv = 1 mod 2^4." + ], + [ + "\\n // ", + "use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256" + ], + [ + "\\n // ", + "less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1" + ], + [ + "\\n // ", + "that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for" + ], + [ + "10", + ", rounded down" + ], + [ + "\\n // ", + "into the expected uint128 result" + ], + [ + "\\n // ", + "every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision" + ], + [ + "pre", + "Sale" + ], + [ + "old", + "Votes" + ], + [ + "// SPDX-License-Identifier: ", + "MIT" + ], + [ + "ig", + "in " + ], + [ + ";\\n ", + "return result" + ], + [ + "\"// SPDX-License-Identifier: MIT", + "\\r\\n" + ], + [ + "constructor", + "(address _" + ], + [ + "....", + "..." + ], + [ + "64", + "\\n inverse *= 2 - denominator * inverse; // inverse mod 2^" + ], + [ + "\\\\", + ":" + ], + [ + "Pool", + "s" + ], + [ + "reg", + "ister " + ], + [ + "sel", + "ves" + ], + [ + "_mint", + "}" + ], + [ + "will be ", + "able to " + ], + [ + ");\\n ", + "assembly {\\n // " + ], + [ + "prod", + "0.\\n " + ], + [ + "call ", + "`" + ], + [ + "Rew", + "ard " + ], + [ + "use ", + "a " + ], + [ + "sum", + " of " + ], + [ + "Initializ", + "ed(" + ], + [ + ".\\n ", + "///////////////////////////////////////////////" + ], + [ + ".\\n ", + "inverse *= 2 - denominator * inverse; // inverse mod 2^8" + ], + [ + ".\\n ", + "result = prod0 * inverse" + ], + [ + "`.\\n *\\n * ", + "The " + ], + [ + ";\\n\\n ", + "unchecked {\\n if (" + ], + [ + "represent", + " a " + ], + [ + "POS", + "IT" + ], + [ + ") internal pure returns (uint256) {\\n ", + "if (a " + ], + [ + "plac", + "e" + ], + [ + "Minter", + "Role" + ], + [ + "admin ", + "for all " + ], + [ + "}.\\n *\\n * ", + "Every successful call to {permit} increases " + ], + [ + "uint256(", + "s) " + ], + [ + ")\\n ", + "prod1 := sub(sub(mm, prod0), lt(mm, prod0" + ], + [ + "createPair", + "(address(this), " + ], + [ + ".\\n */\\n error ", + "Mint" + ], + [ + "::::", + ":" + ], + [ + "********************************", + "****************" + ], + [ + "5d", + "24" + ], + [ + "Using ", + "this function " + ], + [ + "role ", + "bearer" + ], + [ + "` is the ", + "starting " + ], + [ + "hash ", + "digest" + ], + [ + "run", + " " + ], + [ + ".\\n *\\n * IMPORTANT: ", + "The same issues {IERC20-approve} has related to transaction" + ], + [ + "Is", + "sue" + ], + [ + "keccak256(abi.encode", + "(_" + ], + [ + "\\n uint256 ", + "remainder" + ], + [ + "\\n uint256 ", + "prod0; // Least significant 256 bits of the product" + ], + [ + "\\n uint256 ", + "prod1; // Most significant 256 bits of the product" + ], + [ + "\\n uint256 ", + "inverse = (3 * denominator) ^ 2" + ], + [ + ".\\n ", + "prod1 := sub(prod1, gt(remainder, prod0" + ], + [ + ".\\n ", + "remainder := mulmod(x, y, denominator" + ], + [ + "cap", + "ital" + ], + [ + "adminRole", + "` as " + ], + [ + ";\\n // ", + "solhint-disable-next-line no-inline-assembly" + ], + [ + ".\\n // ", + "See https://cs.stackexchange.com/q/138556/92363." + ], + [ + ".\\n // ", + "This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is" + ], + [ + "revokeRole", + "`, it is the " + ], + [ + "IERC721A", + " {\\n /**\\n * " + ], + [ + "))\\n ", + "prod0 := sub(prod0, remainder" + ], + [ + "))\\n ", + "prod0 := mul(x, y" + ], + [ + ";\\n }\\n\\n /**\\n * @notice ", + "Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0" + ], + [ + "result = (result + a / result) >> 1;\\n ", + "return min(result, a / result" + ], + [ + "alloc", + "ate " + ], + [ + "unchecked {\\n // ", + "512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use" + ], + [ + "].sub(", + "subtractedValue, \\\"ERC20: decreased allowance below zero" + ], + [ + "``owner``'s ", + "nonce by one. " + ], + [ + ").\\n */\\n function ", + "sqrt(uint256 a" + ], + [ + ");\\n\\n ", + "///////////////////////////////////////////////" + ], + [ + "Rounding ", + "{\\n Down, // Toward negative " + ], + [ + "2, ", + "rounded down" + ], + [ + ";\\n\\n // ", + "Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also work" + ], + [ + ";\\n\\n // ", + "Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such" + ], + [ + "result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n ", + "result = (result + a / result) >> 1;\\n return min(result, a / result" + ], + [ + "\\n\\n // ", + "Make division exact by subtracting the remainder from [prod1 prod0]." + ], + [ + "\\n\\n // ", + "Because the division is now exact we can divide by multiplying with the modular inverse of denominator" + ], + [ + "\\n\\n // ", + "Does not overflow because the denominator cannot be zero at this stage in the function" + ], + [ + "as part ", + "of the " + ], + [ + "` is set ", + "as " + ], + [ + "\\n * @dev ", + "Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv" + ], + [ + ",\\n // ", + "since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at" + ], + [ + "> 0) {\\n ", + "result += 1;\\n }\\n return result" + ], + [ + "\\\");\\n ", + "require(" + ], + [ + ".\\n unchecked {\\n ", + "result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n " + ], + [ + ";\\n\\nimport \\\"@openzeppelin/contracts/", + "token/ERC20/ERC20" + ], + [ + "must be\\n * ", + "included whenever a signature is generated for {permit" + ], + [ + "core", + "/" + ], + [ + ");\\n }\\n }\\n\\n ", + "/**\\n * @notice Calculates " + ], + [ + "\\n inverse *= 2 - denominator * inverse; // inverse mod 2^", + "16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^" + ], + [ + ")\\n\\n // ", + "Subtract 256 bit number from 512 bit number" + ], + [ + ") internal pure returns (uint256) {\\n uint256 result = ", + "mulDiv(x, y, denominator" + ], + [ + "b7", + "bf" + ], + [ + "address owner = ERC721.ownerOf(tokenId", + ");\\n\\n _beforeTokenTransfer(owner, address(0), tokenId" + ], + [ + "admin role ", + "bearer" + ], + [ + "admin role ", + "for all " + ], + [ + ".\\n if (", + "prod1" + ], + [ + "solmate", + "/src/" + ], + [ + "\\n assembly {\\n ", + "let mm := mulmod(x, y, not(0" + ], + [ + "` or ", + "`" + ], + [ + "0.\\n ", + "require(denominator > prod1" + ], + [ + "https://github.com/OpenZeppelin/openzeppelin-contracts/", + "blob/" + ], + [ + "isOperator", + "Allowed" + ], + [ + "This\\n * ", + "prevents a signature from being used multiple times" + ], + [ + "256 bit ", + "word" + ], + [ + "\"Trading ", + "is not active.\"" + ], + [ + ")\\n * ", + "with further edits by Uniswap Labs also under MIT license" + ], + [ + "ros", + "s" + ], + [ + "handle", + "s the " + ], + [ + "RoleAdminChanged", + "} not being emitted " + ], + [ + "i = 0; i", + " < " + ], + [ + ")\\n }\\n\\n // ", + "Shift in bits from prod1 into " + ], + [ + ")\\n }\\n\\n // ", + "Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1" + ], + [ + " (i.e. ", + "`account`)" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev ", + "Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n " + ], + [ + ";\\n assembly {\\n ", + "size := extcodesize(account" + ], + [ + "/**\\n * @notice Calculates ", + "x * y / denominator with full precision, following the selected rounding direction" + ], + [ + "`, it is the ", + "role bearer" + ], + [ + "twos)\\n\\n // ", + "Divide [prod1 prod0] " + ], + [ + "twos)\\n\\n // ", + "Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes on" + ], + [ + "by twos.\\n ", + "prod0 := div(prod0, " + ], + [ + "by twos.\\n ", + "denominator := div(denominator, " + ], + [ + "infinity\\n ", + "Up, // Toward " + ], + [ + "infinity\\n ", + "Zero // Toward zero" + ], + [ + "- if using `", + "renounceRole" + ], + [ + "- if using `", + "revokeRole`, it is the " + ], + [ + "\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.13", + ";\\n\\nimport {" + ], + [ + "\\n */\\nabstract contract ERC20", + "Burnable is Context" + ], + [ + "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract", + ")\\\"" + ], + [ + "operatorFilter", + "Registry" + ], + [ + "e.\\n ", + "twos := add(div(sub(0, twos), twos), 1" + ], + [ + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n require(b", + " > 0" + ], + [ + "_burn(account, amount", + ");\\n }\\n}\\n\"" + ], + [ + ";\\n }\\n }\\n\\n ", + "/**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction" + ], + [ + "s\\n // ", + "in modular arithmetic, doubling the correct bits in each step" + ], + [ + "its own ", + "admin" + ], + [ + "signature.length == ", + "65" + ], + [ + "incorrect ", + "owner" + ], + [ + "IERC721Receiver(to).onERC721Received.selector", + ";\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert TransferToNonERC721ReceiverImplementer();\\n } else {\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n " + ], + [ + "Minimal", + "Swap" + ], + [ + "accounts with ", + "this role " + ], + [ + "sur", + "rounding " + ], + [ + "\\n }\\n\\n /**\\n * @dev Returns the ", + "largest of two numbers.\\n */\\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a " + ], + [ + ".\\n uint256 ", + "twos = denominator & (~denominator + 1" + ], + [ + "_balances[sender] = _balances[sender", + "].sub(amount, \\\"ERC20: transfer " + ], + [ + "_totalSupply = _totalSupply", + ".sub(" + ], + [ + "b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2;\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute.\\n return ", + "a == 0 ? 0 : (a - 1) / b + 1" + ], + [ + "== 0) {\\n return 0;\\n }\\n\\n // ", + "For our first guess, we get the biggest power of 2 which is smaller than the square root of the target" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender", + ".\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n " + ], + [ + "\"Amount must be less than ", + "total reflection" + ], + [ + "notEnte", + "red " + ], + [ + "s `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer", + "(address(0), to, tokenId);\\n\\n " + ], + [ + "desp", + "ite" + ], + [ + ";\\n }\\n\\n // ", + "Make sure the result is less than 2^256. Also prevents denominator == " + ], + [ + "uint256 result) {\\n ", + "unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use" + ], + [ + "TokenSupplyFor", + "Stage" + ], + [ + "signed approval", + ".\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction" + ], + [ + "curr = tokenId", + ";\\n\\n unchecked {\\n if (" + ], + [ + "Sets `", + "adminRole` as " + ], + [ + "Divide denominator ", + "by twos.\\n denominator := div(denominator, " + ], + [ + "Compute remainder using mulmod", + ".\\n remainder := mulmod(x, y, denominator" + ], + [ + "prod0 |= prod1 * twos", + ";\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such" + ], + [ + "Handle non-overflow cases, 256 by 256 division", + ".\\n if (prod1" + ], + [ + "roles, ", + "despite" + ], + [ + "inverse *= 2 - denominator * inverse; // inverse mod 2^256", + "\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator" + ], + [ + "prod0 / denominator", + ";\\n }\\n\\n // Make sure the result is less than 2^256. Also prevents denominator == " + ], + [ + "sqrt(a), following the selected rounding direction", + ".\\n */\\n function sqrt(uint256 a" + ], + [ + "mulmod(x, y, denominator) ", + "> 0) {\\n result += 1;\\n }\\n return result" + ], + [ + "At this point `result` is an estimation with one bit of precision. We know the true value is a uint128", + ",\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at" + ], + [ + "We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have", + "\\n // " + ], + [ + ");\\n if (rounding == Rounding.Up && ", + "mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result" + ], + [ + "number is not a perfect square, the value is rounded down", + ".\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11" + ], + [ + "128\\n ", + "inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator" + ], + [ + "))\\n }\\n\\n // ", + "Handle non-overflow cases, 256 by 256 division.\\n if (prod1" + ], + [ + ";\\n assembly {\\n // ", + "Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator" + ], + [ + "for `owner`. This value ", + "must be\\n * included whenever a signature is generated for {permit" + ], + [ + "Destroys `amount` tokens from the caller.\\n *\\n * See {ERC20-_burn}.\\n */\\n function burn(uint256 amount) public virtual {\\n _burn(_msgSender(), amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, deducting ", + "from the caller's\\n * allowance.\\n *\\n * See {ERC20-_burn} and {ERC20-allowance}.\\n *\\n * Requirements:\\n *\\n * - the caller must have allowance for ``accounts``'s " + ], + [ + "++, _data)) {\\n ", + "revert TransferToNonERC721ReceiverImplementer();\\n }\\n } while (" + ], + [ + "Extension of {ERC20} that allows token holders to destroy both their own\\n * tokens and those that they have an allowance for, in a way that can be\\n * recognized off-chain (via event analysis).", + "\\n */\\nabstract contract ERC20Burnable is Context" + ], + [ + "grant and ", + "revoke " + ], + [ + "est way to achieve ", + "this is " + ], + [ + "`newAdminRole", + "` is set as " + ], + [ + "effic", + "i" + ], + [ + "32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^", + "64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^" + ], + [ + "signaling ", + "this" + ], + [ + "\\n // is no longer required", + ".\\n result = prod0 * inverse" + ], + [ + "\\n // 512 by 256 division", + ".\\n ///////////////////////////////////////////////" + ], + [ + "\\n // variables such that product = prod1 * 2^256 + prod0.", + "\\n uint256 prod0; // Least significant 256 bits of the product" + ], + [ + "\\n // four bits. That is, denominator * inv = 1 mod 2^4.", + "\\n uint256 inverse = (3 * denominator) ^ 2" + ], + [ + "\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256", + "\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product" + ], + [ + "\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1", + "\\n // is no longer required.\\n result = prod0 * inverse" + ], + [ + "\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for", + "\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2" + ], + [ + "\\n // into the expected uint128 result", + ".\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n " + ], + [ + "\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision", + "\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n " + ], + [ + ";\\n return result", + ";\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction" + ], + [ + ");\\n assembly {\\n // ", + "Divide denominator by twos.\\n denominator := div(denominator, " + ], + [ + "prod0.\\n ", + "prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such" + ], + [ + ".\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8", + "\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^" + ], + [ + ") internal pure returns (uint256) {\\n if (a ", + "== 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target" + ], + [ + "admin for all ", + "roles, despite" + ], + [ + ")\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0", + "))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1" + ], + [ + "` is the starting ", + "admin for all roles, despite" + ], + [ + "\\n uint256 remainder", + ";\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator" + ], + [ + "\\n uint256 prod1; // Most significant 256 bits of the product", + "\\n assembly {\\n let mm := mulmod(x, y, not(0" + ], + [ + ".\\n prod1 := sub(prod1, gt(remainder, prod0", + "))\\n prod0 := sub(prod0, remainder" + ], + [ + ".\\n // See https://cs.stackexchange.com/q/138556/92363.", + "\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function" + ], + [ + ".\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is", + "\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse" + ], + [ + "))\\n prod0 := mul(x, y", + ")\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1" + ], + [ + ";\\n }\\n\\n /**\\n * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0", + "\\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv" + ], + [ + "].sub(subtractedValue, \\\"ERC20: decreased allowance below zero", + "\\\")" + ], + [ + ").\\n */\\n function sqrt(uint256 a", + ") internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target" + ], + [ + ");\\n\\n ///////////////////////////////////////////////", + "\\n // 512 by 256 division.\\n ///////////////////////////////////////////////" + ], + [ + "Rounding {\\n Down, // Toward negative ", + "infinity\\n Up, // Toward " + ], + [ + ";\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also work", + "s\\n // in modular arithmetic, doubling the correct bits in each step" + ], + [ + "result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result", + ");\\n }\\n }\\n\\n /**\\n * @notice Calculates " + ], + [ + "\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].", + "\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator" + ], + [ + ")\\n\\n // Subtract 256 bit number from 512 bit number", + ".\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder" + ], + [ + ") internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator", + ");\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result" + ], + [ + "RoleAdminChanged} not being emitted ", + "signaling this" + ], + [ + ")\\n }\\n\\n // Shift in bits from prod1 into ", + "prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such" + ], + [ + ")\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1", + ".\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function" + ], + [ + "`, it is the role bearer", + " (i.e. `account`)" + ], + [ + "twos)\\n\\n // Divide [prod1 prod0] ", + "by twos.\\n prod0 := div(prod0, " + ], + [ + "twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes on", + "e.\\n twos := add(div(sub(0, twos), twos), 1" + ], + [ + "infinity\\n Zero // Toward zero", + "\\n }\\n\\n /**\\n * @dev Returns the largest of two numbers.\\n */\\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a " + ], + [ + "- if using `renounceRole", + "`, it is the role bearer (i.e. `account`)" + ], + [ + "- if using `revokeRole`, it is the ", + "admin role bearer" + ], + [ + ".\\n uint256 twos = denominator & (~denominator + 1", + ");\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, " + ], + [ + "b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2;\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute.\\n return a == 0 ? 0 : (a - 1) / b + 1", + ";\\n }\\n\\n /**\\n * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv" + ], + [ + "\"Amount must be less than total reflection", + "s\"" + ], + [ + "uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use", + "\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product" + ], + [ + "signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction", + "\\n * ordering also apply here" + ], + [ + "prod0 / denominator;\\n }\\n\\n // Make sure the result is less than 2^256. Also prevents denominator == ", + "0.\\n require(denominator > prod1" + ], + [ + "At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at", + "\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n " + ], + [ + "number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11", + ").\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target" + ], + [ + "128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator", + ".\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse" + ], + [ + "for `owner`. This value must be\\n * included whenever a signature is generated for {permit", + "}.\\n *\\n * Every successful call to {permit} increases " + ], + [ + "Destroys `amount` tokens from the caller.\\n *\\n * See {ERC20-_burn}.\\n */\\n function burn(uint256 amount) public virtual {\\n _burn(_msgSender(), amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, deducting from the caller's\\n * allowance.\\n *\\n * See {ERC20-_burn} and {ERC20-allowance}.\\n *\\n * Requirements:\\n *\\n * - the caller must have allowance for ``accounts``'s ", + "tokens of at least\\n * `amount`.\\n */\\n function burnFrom(address account, uint256 amount) public virtual " + ], + [ + "Extension of {ERC20} that allows token holders to destroy both their own\\n * tokens and those that they have an allowance for, in a way that can be\\n * recognized off-chain (via event analysis).\\n */\\nabstract contract ERC20Burnable is Context", + ", ERC20" + ], + [ + "32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^", + "128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse" + ], + [ + "\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2", + ";\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step" + ], + [ + ".\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^", + "32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse" + ], + [ + "\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0", + "))\\n prod0 := mul(x, y)\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1" + ], + [ + ");\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////", + "\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator" + ], + [ + "Rounding {\\n Down, // Toward negative infinity\\n Up, // Toward ", + "infinity\\n Zero // Toward zero\\n }\\n\\n /**\\n * @dev Returns the largest of two numbers.\\n */\\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a " + ], + [ + "result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates ", + "sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a" + ], + [ + ")\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder", + ")\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function" + ], + [ + ") internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result", + ";\\n }\\n\\n /**\\n * @dev Returns the " + ], + [ + ")\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such", + "\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step" + ], + [ + "twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, ", + "twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1" + ], + [ + ".\\n uint256 twos = denominator & (~denominator + 1);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, ", + "twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1" + ], + [ + "b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2;\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute.\\n return a == 0 ? 0 : (a - 1) / b + 1;\\n }\\n\\n /**\\n * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv", + ")\\n * with further edits by Uniswap Labs also under MIT license" + ], + [ + "uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product", + "\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0))\\n prod0 := mul(x, y)\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1" + ], + [ + "At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n ", + "result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a" + ], + [ + ".\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse", + ";\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction" + ], + [ + ");\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator", + ")\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder)\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function" + ], + [ + ")\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step", + ".\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction" + ], + [ + ".\\n uint256 twos = denominator & (~denominator + 1);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1", + ")\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step.\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction" + ], + [ + ");\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator)\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder)\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function", + ".\\n uint256 twos = denominator & (~denominator + 1);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1)\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step.\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction" + ], + [ + "\"", + "//" + ], + [ + ",", + ") = " + ], + [ + "0", + "% and " + ], + [ + "4", + "20" + ], + [ + "<", + "Extra data " + ], + [ + "B", + "p" + ], + [ + "J", + "av" + ], + [ + "L", + "L" + ], + [ + "a", + "Script " + ], + [ + "d", + "6" + ], + [ + "e", + "quival" + ], + [ + "m", + "id " + ], + [ + "r", + "ong " + ], + [ + "s", + "vg" + ], + [ + "t", + "ask" + ], + [ + "{", + "grantRole} and {revokeRole" + ], + [ + "{", + "grantRole} " + ], + [ + "\\n ", + "* " + ], + [ + ", ", + "IAccessControl" + ], + [ + ", ", + "bytes32 _" + ], + [ + "\\n * ", + "the " + ], + [ + "token", + "s.length" + ], + [ + "is", + "TopLevelCall" + ], + [ + "co", + "re " + ], + [ + "vi", + "a" + ], + [ + "address ", + "_" + ], + [ + "// ", + "If " + ], + [ + "` ", + "identifier" + ], + [ + "of ", + "all the " + ], + [ + "Token", + "\\\", \\\"" + ], + [ + "Re", + "tr" + ], + [ + "no", + "ted " + ], + [ + "no", + "thing" + ], + [ + "ee", + "k" + ], + [ + "\\n * ", + "contract " + ], + [ + " = ", + "(_" + ], + [ + "contract", + "Address" + ], + [ + ",\\n ", + "address" + ], + [ + ". ", + "More complex " + ], + [ + "In", + "cre" + ], + [ + "and ", + "revoked " + ], + [ + "set", + "Min" + ], + [ + ";\\n ", + "uint96 " + ], + [ + "ab", + "solut" + ], + [ + "external ", + "API and " + ], + [ + "that ", + "only " + ], + [ + "string", + ". This " + ], + [ + "Of", + "Bound" + ], + [ + "The ", + "nft contract" + ], + [ + "This ", + "is an alternative to {approve} that can be used as a mitigation " + ], + [ + ", p", + "l" + ], + [ + "this ", + "role. " + ], + [ + "when ", + "using {" + ], + [ + "!= ", + "0" + ], + [ + "role", + "s is `" + ], + [ + "decim", + "al representation" + ], + [ + ") external view returns (", + "bytes32" + ], + [ + ",\\n address ", + "owner,\\n address " + ], + [ + "}\\n ", + "if (" + ], + [ + "` is ", + "also " + ], + [ + "\\n // ", + "This " + ], + [ + "can be ", + "granted " + ], + [ + ") internal virtual ", + "{\\r\\n " + ], + [ + ":= ", + "sload(" + ], + [ + ") private ", + "_roles" + ], + [ + "RE", + "AD" + ], + [ + "Burn", + "er" + ], + [ + ");\\n return ", + "a % b" + ], + [ + ", and ", + "only" + ], + [ + "\"@openzeppelin/contracts/", + "security/ReentrancyGuard.sol\"" + ], + [ + "grant", + " or " + ], + [ + " > ", + "0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : " + ], + [ + "&&", + " (" + ], + [ + "has ", + "permission " + ], + [ + "isi", + "on" + ], + [ + "Set ", + "`" + ], + [ + ".\\n *\\n * _Available since v3.", + "1._" + ], + [ + "admin", + "\\n * " + ], + [ + "admin", + "Role = " + ], + [ + "emit Transfer", + "(address(0), to, updatedIndex" + ], + [ + ") revert ", + "Invalid" + ], + [ + "trading", + "Allowed" + ], + [ + "when", + "Paused " + ], + [ + "r ", + "except " + ], + [ + ", bytes32 ", + "adminRole" + ], + [ + "admin ", + "role, " + ], + [ + ") external returns (bool", + ");\\n\\n /**\\n * @notice " + ], + [ + "\"contracts/", + "interfaces/I" + ], + [ + "have been ", + "granted " + ], + [ + ") external view returns (uint256", + "[] memory" + ], + [ + ", the ", + "admin role for all " + ], + [ + "wei", + "Amount" + ], + [ + "address owner = ", + "ownerOf(tokenId" + ], + [ + "_safeMint", + "(msg.sender, " + ], + [ + "SafeCast", + ".toUint" + ], + [ + "prec", + "aution" + ], + [ + "Contract ", + "= " + ], + [ + "\\n * {", + "RoleAdminChanged} not being emitted signaling this" + ], + [ + "stop", + "Limit" + ], + [ + "calcul", + "ation" + ], + [ + "role ", + "relationship" + ], + [ + "role ", + "has an " + ], + [ + "Account", + " is already " + ], + [ + "> 0", + ") {\\n " + ], + [ + "[]", + "(tokenId" + ], + [ + "recovered", + "Address" + ], + [ + "WARNING: ", + "The `" + ], + [ + "member", + "s;\\n " + ], + [ + "optional ", + "enumeration " + ], + [ + "transfer of ", + "token that is not own" + ], + [ + "\\n ) external returns (", + "uint256 " + ], + [ + "granted `role", + "`.\\n *\\n * `sender` is the account that originated the contract call" + ], + [ + "Sal", + "e " + ], + [ + "gg", + "l" + ], + [ + "DEFAULT_ADMIN_ROLE", + "` is the starting admin for all roles, despite" + ], + [ + ",\\n ", + "\\\"" + ], + [ + ")) ", + "!= " + ], + [ + "cach", + "es" + ], + [ + "replac", + "ing `" + ], + [ + "admin role", + ", and only" + ], + [ + "(address(this), ", + "true" + ], + [ + ";\\n }", + "\\n\\n" + ], + [ + "can call ", + "{grantRole} and {revokeRole" + ], + [ + "beare", + "r except " + ], + [ + "Hel", + "per " + ], + [ + "By default", + ", the admin role for all " + ], + [ + "need", + "ed " + ], + [ + "VRF", + "Consumer" + ], + [ + "utils/Strings", + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev " + ], + [ + "taken to ", + "secure" + ], + [ + "operations", + "Address" + ], + [ + "Spl", + "it" + ], + [ + "mapping(address => uint256) private _balances", + ";\\n\\n // Mapping from token ID to approved address\\n mapping(uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping(address => mapping(address => bool)) private _operatorApprovals" + ], + [ + "(bytes32 role", + ", bytes32 adminRole" + ], + [ + "s.\\n */\\nlibrary ", + "SafeMath {\\n /**\\n * @dev Returns the addition" + ], + [ + "return c", + ";\\n }\\n\\n /**\\n * @dev Returns the " + ], + [ + "domain separator ", + "used in the " + ], + [ + ",\\n address ", + "to" + ], + [ + "accounts that ", + "have been granted " + ], + [ + "totalSupply() ", + "+ " + ], + [ + "admin role ", + "can call {grantRole} and {revokeRole" + ], + [ + "encoding ", + "of the " + ], + [ + ";\\n }\\n", + "}\"" + ], + [ + "solmate", + "/blob/main/src/" + ], + [ + "proper", + "ties" + ], + [ + "bytes32 indexed role", + ", bytes32 indexed " + ], + [ + "Manual", + "NukeLP" + ], + [ + "\\n */\\n event ", + "RoleRevoked(" + ], + [ + "\\n */\\n event ", + "RoleAdminChanged(" + ], + [ + "\\n * ", + "- if using `renounceRole`, it is the role bearer (i.e. `account`)" + ], + [ + "associated ", + "admin role, and only" + ], + [ + "Roles are ", + "referred to " + ], + [ + "\\n // - ", + "case " + ], + [ + "ERC20Votes", + ": " + ], + [ + "Resol", + "ver" + ], + [ + "previousAdminRole", + ", bytes32 indexed " + ], + [ + ") {\\n revert(\\\"ECDSA: invalid signature ", + "length" + ], + [ + "Contract module that ", + "allows children to implement " + ], + [ + "revoke ", + "other" + ], + [ + "tree", + "\\n * " + ], + [ + "newAdminRole", + ");\\n\\n /**\\n * @dev Emitted when `account` is " + ], + [ + "transfer from ", + "incorrect owner" + ], + [ + "Extra ", + "precaution" + ], + [ + "Roles ", + "can be granted " + ], + [ + "check if ", + "an " + ], + [ + "s can be ", + "created by " + ], + [ + "} function", + "s. Each " + ], + [ + "s should be ", + "taken to secure" + ], + [ + ".\\n */\\n function recover", + "(bytes32 hash, bytes memory signature" + ], + [ + "RoleGranted(", + "bytes32 indexed role, address indexed account, address indexed sender" + ], + [ + "`.\\n *\\n * `sender` is the account that originated the contract call", + ":\\n * " + ], + [ + ");\\n\\n /**\\n * @dev Emitted when `account` is ", + "revoked `role" + ], + [ + "} that receives the `v`,\\n * `r` and `s` signature fields separately", + ".\\n */\\n function recover" + ], + [ + "decreased", + "Allowance" + ], + [ + "490", + "6" + ], + [ + ".\\n */\\n function _safeMint(\\n address to", + ",\\n uint256 tokenId" + ], + [ + "RoleData", + ") private _roles" + ], + [ + "At(address registrant, uint256 index) external returns (", + "address" + ], + [ + "via the ", + "{grantRole} " + ], + [ + "balance query for ", + "the zero address" + ], + [ + ": it ", + "has permission " + ], + [ + "Art Block", + "s " + ], + [ + "dynamically ", + "via the {grantRole} " + ], + [ + " is Context, ERC165, IERC721, IERC721Metadata {\\n using Address for address;\\n using Strings for uint256", + ";\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address" + ], + [ + "foo", + "() public " + ], + [ + "\\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n ", + "address owner = ERC721.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner" + ], + [ + "Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721", + " is Context, ERC165, IERC721, IERC721Metadata {\\n using Address for address;\\n using Strings for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address" + ], + [ + "(from, to, tokenId);\\n _afterTokenTransfers(from, to, tokenId, 1", + ");\\n }\\n\\n /**\\n * @dev " + ], + [ + "role-based ", + "access" + ], + [ + "address that signed a hashed message (`hash`) with\\n * `signature`. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it", + ".\\n */\\n function recover(bytes32 hash, bytes memory signature" + ], + [ + "{revokeRole", + "} functions. Each " + ], + [ + ", an ", + "admin role" + ], + [ + "will be able to ", + "grant or " + ], + [ + "its own admin", + ": it has permission " + ], + [ + "accounts with this role ", + "will be able to grant or " + ], + [ + "curr = tokenId;\\n\\n unchecked {\\n if (", + "_startTokenId() <= " + ], + [ + "grant and revoke ", + "this role. " + ], + [ + "- if using `revokeRole`, it is the admin role bearer", + "\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)" + ], + [ + "Jav", + "aScript " + ], + [ + "` identifier", + ". These " + ], + [ + ". More complex ", + "role relationship" + ], + [ + "and revoked ", + "dynamically via the {grantRole} " + ], + [ + "external API and ", + "be " + ], + [ + "that only ", + "accounts with this role will be able to grant or " + ], + [ + "` is also ", + "its own admin: it has permission " + ], + [ + ".\\n *\\n * _Available since v3.1._", + "\\n */\\n event RoleAdminChanged(" + ], + [ + "adminRole = ", + "adminRole" + ], + [ + "admin role, ", + "replacing `" + ], + [ + "\\n * {RoleAdminChanged} not being emitted signaling this", + ".\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(" + ], + [ + "role has an ", + "associated admin role, and only" + ], + [ + "bearer except ", + "when using {" + ], + [ + "By default, the admin role for all ", + "roles is `" + ], + [ + "mapping(address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping(uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping(address => mapping(address => bool)) private _operatorApprovals", + ";\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection" + ], + [ + "accounts that have been granted ", + "it" + ], + [ + "bytes32 indexed role, bytes32 indexed ", + "previousAdminRole, bytes32 indexed " + ], + [ + "Roles are referred to ", + "by their `" + ], + [ + "Contract module that allows children to implement ", + "role-based access" + ], + [ + "newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is ", + "granted `role`.\\n *\\n * `sender` is the account that originated the contract call" + ], + [ + "Extra precaution", + "s should be taken to secure" + ], + [ + "Roles can be granted ", + "and revoked dynamically via the {grantRole} " + ], + [ + "s can be created by ", + "using" + ], + [ + "`.\\n *\\n * `sender` is the account that originated the contract call:\\n * ", + "- if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)" + ], + [ + ");\\n\\n /**\\n * @dev Emitted when `account` is revoked `role", + "`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)" + ], + [ + "{revokeRole} functions. Each ", + "role has an associated admin role, and only" + ], + [ + "grant and revoke this role. ", + "Extra precautions should be taken to secure" + ], + [ + ". More complex role relationship", + "s can be created by using" + ], + [ + "that only accounts with this role will be able to grant or ", + "revoke other" + ], + [ + "admin role, replacing `", + "previousAdminRole" + ], + [ + ");\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)", + "\\n */\\n event RoleRevoked(" + ], + [ + " ", + ": " + ], + [ + ".", + "," + ], + [ + ".", + "2" + ], + [ + ".", + "div(" + ], + [ + ".", + "ownerOf(tokenId" + ], + [ + "2", + "E" + ], + [ + "2", + "a" + ], + [ + "3", + "0 " + ], + [ + "4", + "0 " + ], + [ + "5", + "C" + ], + [ + "B", + "N" + ], + [ + "C", + "alc" + ], + [ + "D", + "ay " + ], + [ + "E", + "P" + ], + [ + "H", + "as" + ], + [ + "U", + "se" + ], + [ + "X", + " " + ], + [ + "[", + "Web" + ], + [ + "_", + "MAX" + ], + [ + "_", + "fallback" + ], + [ + "`", + "\\n * - `" + ], + [ + "b", + "9" + ], + [ + "b", + ") private pure returns (" + ], + [ + "s", + "ert" + ], + [ + "s", + "imilar" + ], + [ + "y", + "list" + ], + [ + "}", + ".\\n * " + ], + [ + "}", + ":\\n *\\n * " + ], + [ + "s ", + "by " + ], + [ + "en", + "." + ], + [ + "\\n ", + "_" + ], + [ + "uint", + ") {\\n " + ], + [ + "ed", + "-" + ], + [ + "\\n * ", + "bearer except when using {" + ], + [ + "the ", + "gas cost of " + ], + [ + "end", + "point" + ], + [ + "it", + "erations" + ], + [ + "\\n ", + "return " + ], + [ + "ed ", + "Data" + ], + [ + "is ", + "effectively " + ], + [ + "to ", + "== " + ], + [ + "` ", + "modifier " + ], + [ + "` ", + "hash digest" + ], + [ + "uint256 ", + "value = " + ], + [ + "d ", + "|| " + ], + [ + "im", + "age" + ], + [ + "ma", + "tion" + ], + [ + "ag", + "ment" + ], + [ + "ERC20", + "Mintable" + ], + [ + "an ", + "event" + ], + [ + "\\n * ", + "```\\n *\\n * " + ], + [ + "\\n * ", + "accounts that have " + ], + [ + "\\n * ", + "accounts that have been granted it" + ], + [ + ".\\n */\\n function ", + "nonces(address owner) external view returns (uint256" + ], + [ + "in ", + "Solidity " + ], + [ + "72", + "33" + ], + [ + "public ", + "constant" + ], + [ + "--", + ";\\n " + ], + [ + "} ", + "{\\n " + ], + [ + "), ", + "amount" + ], + [ + "..", + ".\\n * " + ], + [ + "bytes32", + "` identifier. These " + ], + [ + "value ", + "> 0, \\\"" + ], + [ + "IERC20", + ".sol\"" + ], + [ + ";\\n\\n ", + "bool public " + ], + [ + "e {", + "grantRole" + ], + [ + "this ", + "occur" + ], + [ + "when ", + "setting" + ], + [ + "pure ", + "override returns (" + ], + [ + "Contract", + "Metadata" + ], + [ + "role", + "s for the " + ], + [ + "div", + "Up" + ], + [ + "10", + "), " + ], + [ + ") internal pure returns (", + "uint256) {\\n return " + ], + [ + "Role", + "Data {\\n " + ], + [ + "Pro", + "tection" + ], + [ + "`, ", + "as " + ], + [ + "data ", + "The " + ], + [ + "rou", + "ter " + ], + [ + "will be ", + "true" + ], + [ + "100", + "%" + ], + [ + "::", + "delegateBySig" + ], + [ + "Reward", + "Fee" + ], + [ + "_burn", + "From" + ], + [ + " and ", + "`" + ], + [ + "\\n * `", + "DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite" + ], + [ + "1 ", + "byte " + ], + [ + "v3.", + "3.0" + ], + [ + "given ", + "registrant" + ], + [ + "Us", + "er " + ], + [ + "IERC721Receiver", + ".onERC721Received.selector" + ], + [ + "ST", + "ANT" + ], + [ + "call to ", + "`" + ], + [ + "Typ", + "ed Data" + ], + [ + "way ", + "is effectively " + ], + [ + "factory", + "())." + ], + [ + ", it ", + "will " + ], + [ + "(bytes32 ", + "a" + ], + [ + "(bytes32 ", + "domainSeparator" + ], + [ + "signer", + ", " + ], + [ + ", bytes32 ", + "structHash" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (", + "access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _transferOwnership(_msgSender());\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\"" + ], + [ + ") external returns (bool", + ");\\n\\n function " + ], + [ + ") internal {\\n ", + "if (" + ], + [ + "\\n * @param ", + "account " + ], + [ + "}, ", + "this function " + ], + [ + ", but ", + "we " + ], + [ + "AN", + "C" + ], + [ + "block.number", + ", \\\"" + ], + [ + "filte", + "red by " + ], + [ + "to\\n * ", + "grant and revoke this role. Extra precautions should be taken to secure" + ], + [ + "Role(bytes32 role, address account", + ") internal virtual {\\n _" + ], + [ + " - 1", + "]" + ], + [ + "Account", + "Snapshot" + ], + [ + "Com", + "plet" + ], + [ + "\\n * ", + "...\\n * " + ], + [ + "\\\");\\r\\n ", + "return " + ], + [ + "whenNot", + "Paused(" + ], + [ + "licen", + "se" + ], + [ + "impos", + "ed by {" + ], + [ + "should be ", + "exposed" + ], + [ + "initial ", + "roles for the " + ], + [ + "[from", + "][msg.sender" + ], + [ + "\\n\\t * ", + "@param _" + ], + [ + "),", + "\\n // " + ], + [ + "3c", + "0e" + ], + [ + "string(", + "\\n abi.encodePacked(" + ], + [ + "domainSeparator", + "` and a `" + ], + [ + "(sender, recipient, amount", + ");\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` " + ], + [ + "structHash", + "`. This " + ], + [ + "DEFAULT_ADMIN_ROLE", + "`, which " + ], + [ + "DEFAULT_ADMIN_ROLE", + "` is also its own admin: it has permission " + ], + [ + "and\\n * ", + "{revokeRole} functions. Each role has an associated admin role, and only" + ], + [ + "All ", + "three " + ], + [ + "buil", + "t in " + ], + [ + "}.\\n *\\n * ", + "WARNING: The `" + ], + [ + "}.\\n *\\n * ", + "By default, the admin role for all roles is `" + ], + [ + "_msgSender(), \\\"", + "AccessControl: can only renounce roles for self" + ], + [ + "function call", + ", use {" + ], + [ + "can be used to ", + "represent a " + ], + [ + "Requirements:\\r\\n *\\r", + "\\n * - " + ], + [ + "95", + "2" + ], + [ + ") = _", + "get" + ], + [ + "return\\n ", + "interfaceId == 0x01ffc9a7 || " + ], + [ + "constructor ", + "when setting" + ], + [ + "still ", + "do the " + ], + [ + ", since ", + "this occur" + ], + [ + ", msg.sender", + "));" + ], + [ + "00000000000000000000000000000000", + "000000000000000000000000" + ], + [ + "govern", + "ance " + ], + [ + "bytes32 public constant ", + "MY_ROLE" + ], + [ + "}\\n * ```\\n *\\n * ", + "Roles can be granted and revoked dynamically via the {grantRole} " + ], + [ + ");\\n }\\n\\n ", + "/**\\n * @dev " + ], + [ + "means\\n * ", + "that only accounts with this role will be able to grant or revoke other" + ], + [ + "++i", + ";\\n }\\n " + ], + [ + "core", + "/contracts/interfaces/" + ], + [ + "using `", + "public constant" + ], + [ + "sort", + "ed in " + ], + [ + " = keccak256(\\\"", + "MY_ROLE" + ], + [ + ";\\n }\\n\\n ", + "/**\\n * @dev " + ], + [ + "****************************************************************", + "****************" + ], + [ + "[`eth_sign", + "TypedData" + ], + [ + "go", + "es " + ], + [ + "https://eips.ethereum.org/EIPS/eip-712", + "[`eth_signTypedData" + ], + [ + ".sol\\\";\\nimport \\\"./extensions/", + "IERC721Metadata" + ], + [ + "rid", + "g" + ], + [ + "_ownerships[", + "startTokenId" + ], + [ + "MY_ROLE", + ", msg.sender));" + ], + [ + "✓✓✓✓", + "✓✓✓✓" + ], + [ + "\\r\\n\\t", + "\\tu" + ], + [ + "circumvent", + "ing the " + ], + [ + "\\n * ", + "- " + ], + [ + "ho", + "me/" + ], + [ + "token/ERC721/ERC721", + ".sol\"" + ], + [ + "tokenIdsMaxLength", + " = " + ], + [ + "as well", + " as " + ], + [ + "ToAdd", + "LiquidityWith" + ], + [ + ". Note that ", + "unlik" + ], + [ + "();\\n }\\n\\n ", + "_beforeTokenTransfers(from, address(0), tokenId, 1" + ], + [ + "must not be ", + "paused.\\n */\\n function _" + ], + [ + "_approve(sender, _msgSender(), ", + "currentAllowance - amount" + ], + [ + "Roles ", + "can be used to represent a " + ], + [ + "unique. ", + "The b" + ], + [ + "system ", + "imposed by {" + ], + [ + "caus", + "e " + ], + [ + "with the registry ", + "and " + ], + [ + "RoleRevoked(", + "role, account, _msgSender()" + ], + [ + "RoleGranted(", + "role, account, _msgSender()" + ], + [ + "_setupRole", + "}.\\n */\\n event " + ], + [ + "bytes32 indexed role, address indexed account, address indexed sender", + ");\\n\\n /**\\n * @dev " + ], + [ + "the same ", + "length" + ], + [ + " {\\n enum ", + "Rounding {\\n Down, // Toward negative infinity\\n Up, // Toward infinity\\n Zero // Toward zero\\n }\\n\\n /**\\n * @dev Returns the largest of two numbers.\\n */\\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a " + ], + [ + "toTypedDataHash", + "(bytes32 domainSeparator" + ], + [ + "_operatorApprovals[", + "_msgSender()" + ], + [ + "This function should only be called from the ", + "constructor when setting" + ], + [ + "\\n ) internal pure returns (bool) {\\n return ", + "processProof" + ], + [ + "Register", + "s an address " + ], + [ + "filtered operators and ", + "codeHashes" + ], + [ + "32-byte ", + "word " + ], + [ + "up the ", + "initial roles for the " + ], + [ + "\\n ) external payable ", + "returns (" + ], + [ + ")\\n external\\n payable", + "\\n returns (" + ], + [ + "vrf", + "Coordinator" + ], + [ + "set of permission", + "s. To " + ], + [ + "// File: ", + "@openzeppelin/contracts/" + ], + [ + "Writ", + "e the " + ], + [ + ". However", + ", since this occur" + ], + [ + "/// @solidity memory-safe-assembly\\n ", + "assembly {\\n // " + ], + [ + "227", + "3" + ], + [ + "\\n * roles", + ". More complex role relationships can be created by using" + ], + [ + "require(hasRole(", + "MY_ROLE, msg.sender));" + ], + [ + "Returns an Ethereum Signed ", + "Typed Data" + ], + [ + ",\\n bytes32 root,\\n bytes32 leaf", + "\\n ) internal pure returns (bool) {\\n return processProof" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients", + ".\\n */\\n function _safeMint(\\n address to,\\n uint256 tokenId" + ], + [ + "in any other ", + "way is effectively " + ], + [ + "Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuard {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status;\\n\\n constructor() {\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and ", + "making it call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant(" + ], + [ + "account == ", + "_msgSender(), \\\"AccessControl: can only renounce roles for self" + ], + [ + ".sol\\\";\\nimport \\\"../../utils/Address.sol\\\";\\nimport \\\"../../", + "utils/Context" + ], + [ + "A helper function to ", + "check if an " + ], + [ + "}\\n revert OwnerQueryForNonexistentToken", + "(" + ], + [ + "`\\n *", + "\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite" + ], + [ + "\\n * control ", + "mechanisms" + ], + [ + ", prev", + "Ownership" + ], + [ + "(from, address(0), tokenId);\\n _afterTokenTransfers(from, address(0), tokenId, 1", + ");\\n\\n // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.\\n unchecked {\\n _burnCounter++" + ], + [ + "\\n * in the ", + "external API and be " + ], + [ + "Using this function ", + "in any other way is effectively " + ], + [ + "``owner``'s nonce by one. ", + "This\\n * prevents a signature from being used multiple times" + ], + [ + ";\\n assembly {\\n size := extcodesize(account", + ")\\n }\\n return size > 0" + ], + [ + "for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ", + "``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times" + ], + [ + "(bytes32 role, bytes32 adminRole", + ") internal virtual {\\n " + ], + [ + "admin role can call {grantRole} and {revokeRole", + "}.\\n *\\n * By default, the admin role for all roles is `" + ], + [ + "RoleGranted(bytes32 indexed role, address indexed account, address indexed sender", + ");\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(" + ], + [ + ", an admin role", + "\\n * bearer except when using {" + ], + [ + "\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(", + "bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed " + ], + [ + "Roles are referred to by their `", + "bytes32` identifier. These " + ], + [ + "Contract module that allows children to implement role-based access", + "\\n * control mechanisms" + ], + [ + "newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call", + ", an admin role\\n * bearer except when using {" + ], + [ + "admin role, replacing `previousAdminRole", + "`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite" + ], + [ + "e {grantRole", + "}, this function " + ], + [ + "filtered by ", + "a given address or its subscription.\\n */\\n function " + ], + [ + "to\\n * grant and revoke this role. Extra precautions should be taken to secure", + "\\n * accounts that have been granted it" + ], + [ + "\\n * ...\\n * ", + "}\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} " + ], + [ + "domainSeparator` and a `", + "structHash`. This " + ], + [ + "and\\n * {revokeRole} functions. Each role has an associated admin role, and only", + "\\n * accounts that have " + ], + [ + "built in ", + "overflow " + ], + [ + "function call, use {", + "hasRole" + ], + [ + "still do the ", + "swap " + ], + [ + "bytes32 public constant MY_ROLE", + " = keccak256(\\\"MY_ROLE" + ], + [ + "means\\n * that only accounts with this role will be able to grant or revoke other", + "\\n * roles. More complex role relationships can be created by using" + ], + [ + "using `public constant", + "` hash digest" + ], + [ + ". Note that unlik", + "e {grantRole}, this function " + ], + [ + "Roles can be used to represent a ", + "set of permissions. To " + ], + [ + "unique. The b", + "est way to achieve this is " + ], + [ + "system imposed by {", + "AccessControl" + ], + [ + "_setupRole}.\\n */\\n event ", + "RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(" + ], + [ + "toTypedDataHash(bytes32 domainSeparator", + ", bytes32 structHash" + ], + [ + "up the initial roles for the ", + "system" + ], + [ + "Using this function in any other way is effectively ", + "circumventing the " + ], + [ + "\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed ", + "newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {" + ], + [ + "Roles are referred to by their `bytes32` identifier. These ", + "should be exposed" + ], + [ + "admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite", + "\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {" + ], + [ + "\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} ", + "and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have " + ], + [ + "domainSeparator` and a `structHash`. This ", + "produces hash " + ], + [ + "bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE", + "\\\");" + ], + [ + "means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using", + "\\n * {" + ], + [ + "Roles can be used to represent a set of permissions. To ", + "restrict access to " + ], + [ + "_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(", + "bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev " + ], + [ + "(", + "computedHash, " + ], + [ + "-", + "sign" + ], + [ + "-", + "eth-" + ], + [ + ".", + "set" + ], + [ + "1", + "C" + ], + [ + "1", + "%\"" + ], + [ + "B", + "ACK" + ], + [ + "G", + "EN" + ], + [ + "L", + "N" + ], + [ + "P", + "h" + ], + [ + "W", + "A" + ], + [ + "W", + "ork" + ], + [ + "[", + "ethers" + ], + [ + "b", + "2dcc" + ], + [ + "c", + "at" + ], + [ + "j", + "s]" + ], + [ + "l", + "es" + ], + [ + "s", + "cop" + ], + [ + "s ", + "without " + ], + [ + "ad", + "804" + ], + [ + "\\n * ", + "up the initial roles for the system" + ], + [ + "it", + "t" + ], + [ + "to ", + "whom" + ], + [ + "To", + "Redeem" + ], + [ + "Token", + "ID" + ], + [ + "el", + "e" + ], + [ + "ip", + "edia" + ], + [ + "ag", + "es " + ], + [ + "account", + "s.html#" + ], + [ + "call", + "datacopy" + ], + [ + "an ", + "authorized " + ], + [ + ".\\n *\\n * ", + "See " + ], + [ + ".\\n *\\n * ", + "Using this function in any other way is effectively circumventing the " + ], + [ + "return ", + "buffer" + ], + [ + " = ", + " 0", + ") {\\r\\n " + ], + [ + "perform", + "ing " + ], + [ + "(from, to, tokenId", + ");\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`" + ], + [ + "assembly {", + " " + ], + [ + "signer", + "/#" + ], + [ + ", bytes32 ", + "b) private pure returns (" + ], + [ + "let ", + "length" + ], + [ + "take", + "Fee = " + ], + [ + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev ", + "Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuard {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status;\\n\\n constructor() {\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and making it call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant(" + ], + [ + "CON", + "STANT" + ], + [ + "} event.\\n */\\n function _", + "setRoleAdmin" + ], + [ + "5d", + "85" + ], + [ + ") >> ", + "255" + ], + [ + "Withdraw", + "al" + ], + [ + "Data ", + "memory " + ], + [ + "startTimestamp", + " = = " + ], + [ + "There ", + "is " + ], + [ + " of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function try", + "Add" + ], + [ + " of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function try", + "Sub" + ], + [ + "burned = ", + "false" + ], + [ + "Farm", + "ing" + ], + [ + "bytes32) {\\n return _", + "roles[role].adminRole" + ], + [ + "Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event", + ". Note that unlike {grantRole}, this function " + ], + [ + "charg", + "e" + ], + [ + "CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {", + "trySub" + ], + [ + "RoleAdminChanged", + "} event.\\n */\\n function _setRoleAdmin" + ], + [ + "docs.", + "ethers.io/v5" + ], + [ + "\\n mapping(uint256 => address) private ", + "_owners;\\n\\n // Mapping owner address to token count\\n " + ], + [ + "BAS", + "E_" + ], + [ + "c9", + "27e" + ], + [ + "addr = ", + "
>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = _HEX_SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n}\\n\"" + ], + [ + "domain separator used in the ", + "encoding of the " + ], + [ + "RoleData) private _roles", + ";\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00" + ], + [ + "foo() public ", + "{\\n * require(hasRole(MY_ROLE, msg.sender));" + ], + [ + "en.", + "wikipedia" + ], + [ + "\\n * ```\\n *\\n * ", + "Roles can be used to represent a set of permissions. To restrict access to " + ], + [ + "7233", + "c927e" + ], + [ + "(bytes32 a", + ", bytes32 b) private pure returns (" + ], + [ + "Role(bytes32 role, address account) internal virtual {\\n _", + "grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as " + ], + [ + "DEFAULT_ADMIN_ROLE`, which ", + "means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {" + ], + [ + "DEFAULT_ADMIN_ROLE` is also its own admin: it has permission ", + "to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it" + ], + [ + "2273", + "b7bfad804" + ], + [ + "account == _msgSender(), \\\"AccessControl: can only renounce roles for self", + "\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function " + ], + [ + "\\n * in the external API and be ", + "unique. The best way to achieve this is " + ], + [ + "admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `", + "DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {" + ], + [ + "Roles are referred to by their `bytes32` identifier. These should be exposed", + "\\n * in the external API and be unique. The best way to achieve this is " + ], + [ + "bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");", + "\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to " + ], + [ + "LN", + "_36_" + ], + [ + "\\n * up the initial roles for the system", + ".\\n *\\n * Using this function in any other way is effectively circumventing the " + ], + [ + "accounts.html#", + "sign[Web" + ], + [ + "3.4/", + "web3-eth-" + ], + [ + "signature generation", + ":" + ], + [ + ");\\n _roles[role].", + "adminRole = adminRole" + ], + [ + "temp := div(", + "temp, 10" + ], + [ + "defined by {", + "EIP712" + ], + [ + "5d85", + "a4" + ], + [ + "3ca8", + "2273b7bfad804" + ], + [ + "readthedocs.io/en/v1.", + "3.4/web3-eth-" + ], + [ + "703c0e", + "500b65" + ], + [ + "perform any\\n * ", + "checks on the calling account.\\n *\\n * " + ], + [ + "a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction", + " of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub" + ], + [ + "7db2dcc", + "703c0e500b65" + ], + [ + "Signer-sign", + "Message[ethers" + ], + [ + "multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function try", + "Mul" + ], + [ + "by\\n * using `public constant` hash digest", + "s:\\n *\\n * " + ], + [ + "_setRoleAdmin}.\\n *\\n * WARNING: The `", + "DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it" + ], + [ + "bytes32) {\\n return _roles[role].adminRole", + ";\\n }\\n\\n /**\\n * @dev " + ], + [ + "docs.ethers.io/v5", + "/api/signer/#" + ], + [ + "\\n mapping(uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n ", + "mapping(address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping(uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping(address => mapping(address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection" + ], + [ + ".\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin", + "(bytes32 role, bytes32 adminRole) internal virtual {\\n " + ], + [ + ", add(48, ", + "mod(temp, 10))" + ], + [ + "web3js.", + "readthedocs.io/en/v1.3.4/web3-eth-" + ], + [ + "a\\n * function call, use {hasRole", + "}:\\n *\\n * " + ], + [ + "On the first call to nonReentrant, _notEntered ", + "will be true" + ], + [ + "Documentation for ", + "signature generation:" + ], + [ + "[WARNING]\\n * ====\\n * This function should only be called from the constructor when setting", + "\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the " + ], + [ + "5d2460186f", + "7233c927e" + ], + [ + "admin\\n * system imposed by {AccessControl", + "}.\\n * " + ], + [ + "domain separator used in the encoding of the ", + "signature " + ], + [ + "foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));", + "\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have " + ], + [ + "en.wikipedia", + ".org/wiki/" + ], + [ + "admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {", + "_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it" + ], + [ + "Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is ", + "by\\n * using `public constant` hash digests:\\n *\\n * " + ], + [ + "bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to ", + "a\\n * function call, use {hasRole}:\\n *\\n * " + ], + [ + "accounts.html#sign[Web", + "3.js]" + ], + [ + "3ca82273b7bfad804", + "5d85a4" + ], + [ + "7db2dcc703c0e500b65", + "3ca82273b7bfad8045d85a4" + ], + [ + "docs.ethers.io/v5/api/signer/#", + "Signer-signMessage[ethers" + ], + [ + "web3js.readthedocs.io/en/v1.3.4/web3-eth-", + "accounts.html#sign[Web3.js]" + ], + [ + "[WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the ", + "admin\\n * system imposed by {AccessControl}.\\n * " + ], + [ + "5d2460186f7233c927e", + "7db2dcc703c0e500b653ca82273b7bfad8045d85a4" + ], + [ + ",", + "\\n " + ], + [ + "-", + "2098 short " + ], + [ + "1", + " > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base " + ], + [ + "2", + " > 0) {\\n value >>= " + ], + [ + "3", + "78" + ], + [ + "4", + " > 0) {\\n value >>= " + ], + [ + "5", + "23" + ], + [ + "8", + " > 0) {\\n value >>= " + ], + [ + "8", + " > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base " + ], + [ + "A", + "8" + ], + [ + "F", + "OR" + ], + [ + "T", + "er" + ], + [ + "]", + "++" + ], + [ + "_", + "not" + ], + [ + "_", + "HEX_SYMBOLS" + ], + [ + "b", + "ound " + ], + [ + "c", + "d || " + ], + [ + "g", + "am" + ], + [ + "g", + "oo" + ], + [ + "h", + "our" + ], + [ + "h", + "eld" + ], + [ + "i", + "on " + ], + [ + "w", + "indow" + ], + [ + "╣", + "╣" + ], + [ + "re", + "am" + ], + [ + "th", + "res" + ], + [ + "ad", + "ult" + ], + [ + "25", + "2" + ], + [ + "uint256", + ");\\n\\n function " + ], + [ + "ex", + "i" + ], + [ + "ed ", + "on " + ], + [ + "d ", + "= " + ], + [ + "@dev", + " " + ], + [ + "public", + "\\r\\n " + ], + [ + "abl", + "es" + ], + [ + "s (", + "such as " + ], + [ + ".\\n *\\n * ", + "Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex " + ], + [ + "Fee", + "Bps" + ], + [ + "over", + "all" + ], + [ + ". ", + "The" + ], + [ + ". ", + "All " + ], + [ + "\\t", + "function " + ], + [ + " to ", + "a " + ], + [ + "ck", + "et " + ], + [ + "\\r\\n ", + ");\\r\\n\\r\\n " + ], + [ + ") external ", + "view virtual " + ], + [ + "IERC20", + "(_" + ], + [ + "> ", + "b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2;\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute.\\n return a == 0 ? 0 : (a - 1) / b + 1;\\n }\\n\\n /**\\n * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\\n * with further edits by Uniswap Labs also under MIT license" + ], + [ + "}\\n", + "}\"" + ], + [ + "\\n // ", + "the " + ], + [ + "Rec", + "ord" + ], + [ + "/// ", + "@param " + ], + [ + "import \\\"", + "../" + ], + [ + "` to ", + "be " + ], + [ + "amount ", + "The " + ], + [ + "AT", + "CH" + ], + [ + "id ", + "== " + ], + [ + "user", + "Reward" + ], + [ + "\"@openzeppelin/contracts/", + "access/AccessControl" + ], + [ + "\"@openzeppelin/contracts/", + "token/ERC721/ERC721.sol\"" + ], + [ + "non-", + "reverting " + ], + [ + ".\\n ", + "uint256 result = 1 << (log2(a) >> 1" + ], + [ + "ind", + "ow " + ], + [ + "128", + ";\\n }\\n if (value >> " + ], + [ + "we ", + "already " + ], + [ + "buffer", + ", " + ], + [ + ");\\n\\n /**\\n * @dev Returns the ", + "domain separator used in the encoding of the signature " + ], + [ + "mis", + "match" + ], + [ + "\\r\\n ", + " */\\r\\n function " + ], + [ + ") / ", + "1000" + ], + [ + "0.8.", + "4" + ], + [ + ");\\n\\n // ", + "At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a" + ], + [ + "uint32", + " _" + ], + [ + "s.\\n *\\n * ", + "The " + ], + [ + "[EIP", + "-2098 short " + ], + [ + "optim", + "ized " + ], + [ + ";\\n }\\n if (value >> ", + "32 > 0) {\\n value >>= " + ], + [ + ";\\n }\\n if (value >> ", + "16 > 0) {\\n value >>= 16;\\n result += " + ], + [ + "manag", + "ement" + ], + [ + ".sol'", + ";\\n\\n/**\\n * @dev Interface of " + ], + [ + "maxTransactionAmount", + " " + ], + [ + ": invalid ", + "multiproof" + ], + [ + "log2", + "(value);\\n return result + (rounding == Rounding.Up && " + ], + [ + ".\\n // ", + "The " + ], + [ + "on behalf ", + "of " + ], + [ + "blacklist", + "s" + ], + [ + "_balances[from", + "] -= 1;\\n " + ], + [ + "random", + "izer" + ], + [ + ", of a positive value.\\n * Returns 0 if given 0", + ".\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex " + ], + [ + "paused ", + "state" + ], + [ + "MerkleProof", + ": invalid multiproof" + ], + [ + "sqrt(a", + ");\\n return result + (rounding == Rounding.Up && " + ], + [ + "Interface of the ERC20 ", + "Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on " + ], + [ + "_packedAddressData", + "[owner" + ], + [ + "log256", + "(value);\\n return result + (rounding == Rounding.Up && " + ], + [ + "log256", + "(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = " + ], + [ + "log256", + "(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += " + ], + [ + "log10", + "(value);\\n return result + (rounding == Rounding.Up && " + ], + [ + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function ", + "log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = " + ], + [ + ")\\n external\\n view\\n returns (", + "\\n " + ], + [ + "Initial", + "Supply" + ], + [ + "r` and `", + "vs` short-signature fields separately" + ], + [ + "(bytes32 hash", + ") internal pure returns (bytes32" + ], + [ + ">= amount, \\\"ERC20: transfer ", + "amount exceeds allowance" + ], + [ + ") external;\\n\\n /**\\n * @dev Returns the ", + "current nonce " + ], + [ + "} that receives the `", + "r` and `vs` short-signature fields separately" + ], + [ + ", Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = ", + "sqrt(a);\\n return result + (rounding == Rounding.Up && " + ], + [ + "AI", + "LED" + ], + [ + "keep", + " the " + ], + [ + "PRIC", + "E_PRECISION" + ], + [ + "decimals = ", + "decimals_" + ], + [ + ", address[] calldata path", + ") external view returns (" + ], + [ + "numTokens", + "SellToAddTo" + ], + [ + "32;\\n result += ", + "4;\\n }\\n if (value >> " + ], + [ + "16;\\n result += ", + "16" + ], + [ + "64;\\n result += ", + "8;\\n }\\n if (value >> " + ], + [ + "(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = ", + "log2(value);\\n return result + (rounding == Rounding.Up && " + ], + [ + "(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = ", + "log10(value);\\n return result + (rounding == Rounding.Up && " + ], + [ + ");\\n }\\n }\\n\\n /**\\n * @dev Return the log in base ", + "2, rounded down" + ], + [ + "(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value ", + ">= " + ], + [ + "result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base ", + "10, following the selected rounding direction" + ], + [ + "}\\n\\n return ", + "result" + ], + [ + "\\n //\\n // ", + "This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)" + ], + [ + "\\n //\\n // ", + "Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit" + ], + [ + "s[0", + "]" + ], + [ + ".\\n //\\n // ", + "We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // " + ], + [ + ") public view virtual override returns (uint256) {\\n require(", + "index < " + ], + [ + "Balancer", + "Errors" + ], + [ + "Des", + "tin" + ], + [ + ",\\n bytes memory userData", + "\\n " + ], + [ + "string memory baseURI = _baseURI();\\n return bytes(baseURI).length", + " > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : " + ], + [ + "interfaceId == 0x", + "80ac58" + ], + [ + "uint amountToken, uint amountETH", + ", uint liquidity" + ], + [ + "2;\\n }\\n if (value >> ", + "1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base " + ], + [ + "2;\\n }\\n if (value >> ", + "8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base " + ], + [ + "4;\\n result += ", + "4" + ], + [ + "4;\\n result += ", + "4;\\n }\\n if (value >> " + ], + [ + "8;\\n result += ", + "8" + ], + [ + "8;\\n result += ", + "8;\\n }\\n if (value >> " + ], + [ + "32 > 0) {\\n value >>= ", + "32;\\n result += 4;\\n }\\n if (value >> " + ], + [ + "\\n * - with https://", + "docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers" + ], + [ + "\\n * - with https://", + "web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]" + ], + [ + "16;\\n }\\n if (value >> ", + "64 > 0) {\\n value >>= " + ], + [ + "16;\\n }\\n if (value >> ", + "8 > 0) {\\n value >>= " + ], + [ + "64 > 0) {\\n value >>= ", + "64;\\n result += 64" + ], + [ + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2", + "(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += " + ], + [ + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2", + "(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && " + ], + [ + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10", + "(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && " + ], + [ + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10", + "(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= " + ], + [ + "32;\\n result += 32", + ";\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += " + ], + [ + "result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base ", + "256, rounded down" + ], + [ + "result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base ", + "10, rounded down" + ], + [ + "`\\n // → `", + "2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`" + ], + [ + "`\\n // → `", + "sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))" + ], + [ + "16 > 0) {\\n value >>= 16;\\n result += ", + "2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base " + ], + [ + "Internal", + "Balance" + ], + [ + ".\\n mstore(0x", + "40, " + ], + [ + "keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n", + "32\\\", " + ], + [ + "DOMAIN_SEPARATOR() external view returns (bytes32", + ");\\n}\\n\"" + ], + [ + "2;\\n result += ", + "2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base " + ], + [ + "_SWAP", + "_FEE_PERCENT" + ], + [ + "https://eips.ethereum.org/EIPS/eip-2098", + "[EIP-2098 short " + ], + [ + "1 << ", + "result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down" + ], + [ + "_approve(address(this), address(uniswapV2Router), ", + "tokenAmount" + ], + [ + "custom:", + "oz" + ], + [ + ");\\n\\n // Clear approvals\\n ", + "_approve(address(0), tokenId);\\n\\n " + ], + [ + "_buyer", + "Map" + ], + [ + "1) {\\n ", + "result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction" + ], + [ + "tokenId < _currentIndex", + " && " + ], + [ + "string.\\n */\\n function ", + "log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += " + ], + [ + "(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n ", + "_balances[from] -= 1;\\n " + ], + [ + "2, following the selected rounding direction", + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && " + ], + [ + "result * result < a ? 1 : 0", + ");\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down" + ], + [ + "square root of a number. If the ", + "number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target" + ], + [ + "`msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.", + "\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)" + ], + [ + "MinimalSwap", + "Info" + ], + [ + "`newAdminRole` is set as ", + "``role``'s " + ], + [ + "signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here", + ".\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function " + ], + [ + ") internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the ", + "square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target" + ], + [ + "of all the ", + "tokens " + ], + [ + ".\\n */\\n function nonces(address owner) external view returns (uint256", + ");\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature " + ], + [ + "for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times", + ".\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature " + ], + [ + "defined by {EIP712", + "}.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function " + ], + [ + "2 > 0) {\\n value >>= ", + "2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base " + ], + [ + "4 > 0) {\\n value >>= ", + "4;\\n result += 4;\\n }\\n if (value >> " + ], + [ + "non-reverting ", + "call" + ], + [ + ".\\n uint256 result = 1 << (log2(a) >> 1", + ");\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a" + ], + [ + "128;\\n }\\n if (value >> ", + "64 > 0) {\\n value >>= 64;\\n result += 64" + ], + [ + ";\\n }\\n if (value >> 32 > 0) {\\n value >>= ", + "32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += " + ], + [ + ", of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex ", + "string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += " + ], + [ + "log256(value);\\n return result + (rounding == Rounding.Up && ", + "1 << (" + ], + [ + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = ", + "log256(value);\\n return result + (rounding == Rounding.Up && 1 << (" + ], + [ + ") external;\\n\\n /**\\n * @dev Returns the current nonce ", + "for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature " + ], + [ + ", Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && ", + "result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down" + ], + [ + "64;\\n result += 8;\\n }\\n if (value >> ", + "32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> " + ], + [ + "\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit", + ".\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a" + ], + [ + ".\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // ", + "`msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)" + ], + [ + "interfaceId == 0x80ac58", + "cd || " + ], + [ + "8;\\n result += 8;\\n }\\n if (value >> ", + "4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> " + ], + [ + "16;\\n }\\n if (value >> 64 > 0) {\\n value >>= ", + "64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> " + ], + [ + "16;\\n }\\n if (value >> 8 > 0) {\\n value >>= ", + "8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> " + ], + [ + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += ", + "128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64" + ], + [ + "result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down", + ", of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += " + ], + [ + "`\\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`", + "\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a" + ], + [ + "`\\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))", + "`\\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a" + ], + [ + "keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n32\\\", ", + "hash" + ], + [ + "https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short ", + "signatures" + ], + [ + "1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down", + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= " + ], + [ + "1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction", + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && " + ], + [ + "2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && ", + "1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= " + ], + [ + ") internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target", + ".\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)" + ], + [ + "2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base ", + "2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= " + ], + [ + ";\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += ", + "16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> " + ], + [ + ", Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down", + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64" + ], + [ + "16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> ", + "16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base " + ], + [ + "result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += ", + "16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base " + ], + [ + "`\\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a", + ", Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64" + ], + [ + ") internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)", + "`\\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64" + ], + [ + ";\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> ", + "2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= " + ], + [ + ") internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64", + ";\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> 2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= " + ], + [ + " ", + "+ _" + ], + [ + "'", + ");\\n " + ], + [ + "-", + "token" + ], + [ + "=", + "0" + ], + [ + "D", + "ead" + ], + [ + "D", + "RA" + ], + [ + "E", + "gg" + ], + [ + "F", + "utu" + ], + [ + "H", + "drn" + ], + [ + "M", + "aster" + ], + [ + "S", + "YMBOLS" + ], + [ + "T", + "C" + ], + [ + "_", + "num" + ], + [ + "a", + "3" + ], + [ + "b", + "d" + ], + [ + "b", + "al" + ], + [ + "c", + "es " + ], + [ + "u", + "q" + ], + [ + "x", + "f" + ], + [ + "s ", + "it" + ], + [ + "\\n ", + ");\\n _" + ], + [ + ", ", + "mul(" + ], + [ + "ed", + "/" + ], + [ + "25", + "00" + ], + [ + "\\n * ", + "quantity - the amount to be transferred" + ], + [ + "is", + "Registered" + ], + [ + "\\\"", + ") {\\n " + ], + [ + "ERC", + "1363" + ], + [ + ".\\n *\\n * ", + "startTokenId - the first token id to be transferred" + ], + [ + "rec", + "ord" + ], + [ + "In", + "Max" + ], + [ + "index", + "Out" + ], + [ + "} ", + "1 {" + ], + [ + "total", + "Amount" + ], + [ + "imp", + "ort" + ], + [ + "private ", + "_decimals" + ], + [ + "with", + "\\n // " + ], + [ + "that ", + "all " + ], + [ + "that ", + "doesn't " + ], + [ + "string ", + "public constant " + ], + [ + ") public ", + "view returns(" + ], + [ + "burn", + "Amount" + ], + [ + " is ", + "ERC20, " + ], + [ + "ard", + "s to " + ], + [ + "Mint", + "(" + ], + [ + "pa", + "users" + ], + [ + " * ", + "1e18" + ], + [ + "bytes32 ", + "merkleRoot" + ], + [ + "will ", + "have " + ], + [ + "With", + "Fee" + ], + [ + "balanceOf", + "} to enumerate " + ], + [ + "mod", + "(value, " + ], + [ + "div", + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n return " + ], + [ + "div", + "(a, b" + ], + [ + "block", + "ForPenalty" + ], + [ + "string memory ", + "buffer = new " + ], + [ + " b", + "reak" + ], + [ + "] = ", + "_SYMBOLS" + ], + [ + "{\\n ", + "struct " + ], + [ + "safe", + "32" + ], + [ + ",\\n address ", + "owner" + ], + [ + "s, ", + "bool " + ], + [ + "Ch", + "arg" + ], + [ + "using ", + "SafeERC20 for IERC20" + ], + [ + "+= ", + "(fees * " + ], + [ + "tw", + "ards to " + ], + [ + "\\\");\\n\\n ", + "_transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function " + ], + [ + "Admin", + "istr" + ], + [ + "Imp", + "lied" + ], + [ + "fir", + "mation" + ], + [ + "back", + " to the " + ], + [ + "burned", + "` " + ], + [ + ".\\n ", + "uint256 internal " + ], + [ + "\\n *\\n * ", + "Calling conditions:\\n *\\n * - " + ], + [ + "signature ", + "expired" + ], + [ + "Allow", + "s the " + ], + [ + "delegat", + "ed " + ], + [ + ")\\n ", + "public" + ], + [ + ".sol\\\";\\n\\n/**\\n * @dev ", + "Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum." + ], + [ + "if (value ", + "== 0) " + ], + [ + "Solidity ", + "code" + ], + [ + "owned by ", + "`owner` " + ], + [ + "() external ", + "view returns(" + ], + [ + "ECDSA", + ".sol\"" + ], + [ + ";\\n emit ", + "OwnershipTransferred(address(0), msgSender" + ], + [ + "Last", + "X128" + ], + [ + "712", + ".\\n *\\n * See {recover}.\\n */\\n function " + ], + [ + "to the ", + "one signed with the\\n * " + ], + [ + "lib/", + "Constant" + ], + [ + "let ", + "m" + ], + [ + "currentAllowance ", + ">= amount, \\\"ERC20: transfer amount exceeds allowance" + ], + [ + ".sol\\\";\\n\\n", + "// " + ], + [ + "supportsInterface(bytes4 interfaceId", + ")\\n public\\n view\\n virtual\\n override(" + ], + [ + "interfaceId == ", + "0x5b5e139f" + ], + [ + "(address(this", + ")." + ], + [ + "Chain", + "Id " + ], + [ + "```", + "\\n * function " + ], + [ + "Cannot ", + "set " + ], + [ + "Sh", + "eep" + ], + [ + "stop", + "`)" + ], + [ + "INITIAL", + "_DOMAIN_SEPARATOR" + ], + [ + "INITIAL", + "_CHAIN_ID" + ], + [ + "Withdraw", + " " + ], + [ + "term", + " = ((" + ], + [ + "term", + " * x" + ], + [ + "swap ", + "fees" + ], + [ + "- the ", + "source " + ], + [ + ");\\n }\\n ", + "}\\n }\\n\\n function " + ], + [ + "should", + "TakeFee" + ], + [ + "\\n override", + "(" + ], + [ + "string(", + "length" + ], + [ + "do ", + "nothing" + ], + [ + ";\\n\\n ", + "function " + ], + [ + "(address(this), ", + "subscriptionOrRegistrantToCopy" + ], + [ + "add(32, ", + "length" + ], + [ + "));\\n }\\n\\n /**\\n * @dev ", + "Returns an Ethereum Signed Typed Data" + ], + [ + "VAL", + "U" + ], + [ + "\\n return ", + "keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n32\\\", hash" + ], + [ + "VR", + "G" + ], + [ + "method", + "s." + ], + [ + "balanceOf(address(this", + "))" + ], + [ + ");\\n\\n // ", + "@notice " + ], + [ + "This is ", + "a " + ], + [ + "Reser", + "ved" + ], + [ + "corresponding\\n * ", + "to the one signed with the\\n * " + ], + [ + "x_", + "n" + ], + [ + "{\\n using ", + "SafeMath for uint256" + ], + [ + ")\\n internal", + "\\n view" + ], + [ + "log256", + "(value) + " + ], + [ + "log10", + "(value) + " + ], + [ + "assembly {\\n ", + "r := mload(add(signature, 0x20" + ], + [ + "hsi", + "Index" + ], + [ + "[i", + "]." + ], + [ + "ONE_20", + ") / " + ], + [ + ");\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to", + "`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes calldata data\\n " + ], + [ + "math/SafeMath", + ".sol\"" + ], + [ + "new uint256", + "[](" + ], + [ + "mstore8(", + "ptr, " + ], + [ + "disabl", + "ing " + ], + [ + "_approve(_msgSender(), spender, _allowances[_msgSender()][spender", + "].add(addedValue)" + ], + [ + "`]\\n * JSON-RPC method as part of EIP-", + "712.\\n *\\n * See {recover}.\\n */\\n function " + ], + [ + "accumul", + "ator" + ], + [ + "entri", + "es " + ], + [ + "solidity-utils/contracts/", + "helpers/" + ], + [ + "emits an ", + "event" + ], + [ + "compute", + "DomainSeparator" + ], + [ + "_balances[owner", + "] -= 1;\\n " + ], + [ + "tokens.\\n */\\n function ", + "tokenOfOwnerByIndex(address owner, uint256 index" + ], + [ + "byte(", + "mod(value, " + ], + [ + ");\\n uint256 c = ", + "a - b" + ], + [ + "of its ", + "token list" + ], + [ + "updateMax", + "TxnAmount" + ], + [ + "at a given `index` ", + "of its token list" + ], + [ + ".\\n * Use along with {", + "balanceOf} to enumerate " + ], + [ + ");\\n _owner = ", + "address(0" + ], + [ + "UintToAddress", + "Map" + ], + [ + "\"Swap amount cannot be ", + "higher than " + ], + [ + "Correction", + "s" + ], + [ + "ticket", + "TokenId" + ], + [ + "lef", + "twards to " + ], + [ + ".sol\\u0027", + ";\\n" + ], + [ + "Trigg", + "ers " + ], + [ + ".sol\\\";\\nimport \\\"../../utils/introspection/ERC165.sol\\\";\\n\\n/**\\n * @dev ", + "Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721 is Context, ERC165, IERC721, IERC721Metadata {\\n using Address for address;\\n using Strings for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address" + ], + [ + ";\\n // ecrecover takes the signature parameters, and the only way to get them\\n // currently is to use assembly.\\n ", + "assembly {\\n r := mload(add(signature, 0x20" + ], + [ + "DR", + "N" + ], + [ + "_balances[recipient] = _balances[recipient", + "].add(amount);\\n emit Transfer" + ], + [ + "feeGrowth", + "Inside" + ], + [ + "interfaces/contracts/solidity-utils/", + "helpers/" + ], + [ + "`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId", + ") external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool" + ], + [ + "assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev ", + "Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be " + ], + [ + "ptr := add(", + "buffer, " + ], + [ + "emit OwnershipTransferred(_owner, address(0)", + ");\\n _owner = address(0" + ], + [ + ", uint reserveIn, uint reserveOut", + ") external pure returns (" + ], + [ + "Returns an Ethereum Signed Message, created from a `hash", + "`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash" + ], + [ + ", created from a\\n * `", + "domainSeparator` and a `structHash`. This produces hash " + ], + [ + ") {\\n // 32 is the length in bytes of hash,\\n // enforced by the type signature above", + "\\n return keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n32\\\", hash" + ], + [ + ".sol\\\";\\nimport \\\"../../utils/Strings", + ".sol\\\";\\nimport \\\"../../utils/introspection/ERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721 is Context, ERC165, IERC721, IERC721Metadata {\\n using Address for address;\\n using Strings for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address" + ], + [ + ") < value ? 1 : 0", + ");\\n }\\n }\\n}\\n\"" + ], + [ + "\"//", + "SPDX-License-Identifier: " + ], + [ + "This is an alternative to {approve} that can be used as a mitigation ", + "for" + ], + [ + "[](tokenId", + "s" + ], + [ + "10), ", + "_SYMBOLS" + ], + [ + "https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData", + "`]\\n * JSON-RPC method as part of EIP-712.\\n *\\n * See {recover}.\\n */\\n function " + ], + [ + ".sol\\\";\\nimport \\\"../../utils/Address.sol\\\";\\nimport \\\"../../utils/Context", + ".sol\\\";\\nimport \\\"../../utils/Strings.sol\\\";\\nimport \\\"../../utils/introspection/ERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721 is Context, ERC165, IERC721, IERC721Metadata {\\n using Address for address;\\n using Strings for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address" + ], + [ + "IERC721.sol\\\";\\nimport \\\"./IERC721Receiver", + ".sol\\\";\\nimport \\\"./extensions/IERC721Metadata" + ], + [ + "Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested", + ".\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a " + ], + [ + "(bytes32 hash) internal pure returns (bytes32", + ") {\\n // 32 is the length in bytes of hash,\\n // enforced by the type signature above\\n return keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n32\\\", hash" + ], + [ + "string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ", + "\\\"\\\";\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\\n * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\\n * by default, can be " + ], + [ + ");\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n ", + "_balances[owner] -= 1;\\n " + ], + [ + "`newAdminRole` is set as ``role``'s ", + "admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {" + ], + [ + "defined by {EIP712}.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function ", + "DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\"" + ], + [ + "SYMBOLS", + " = \\\"0123456789abcdef" + ], + [ + "\\n * quantity - the amount to be transferred", + "\\n *\\n * Calling conditions:\\n *\\n * - " + ], + [ + ".\\n *\\n * startTokenId - the first token id to be transferred", + "\\n * quantity - the amount to be transferred\\n *\\n * Calling conditions:\\n *\\n * - " + ], + [ + "string memory buffer = new ", + "string(length" + ], + [ + "if (value == 0) ", + "break" + ], + [ + "owned by `owner` ", + "at a given `index` of its token list" + ], + [ + "interfaceId == 0x5b5e139f", + "; // " + ], + [ + "term = ((", + "term * x" + ], + [ + "));\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Typed Data", + ", created from a\\n * `domainSeparator` and a `structHash`. This produces hash " + ], + [ + "corresponding\\n * to the one signed with the\\n * ", + "https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\\n * JSON-RPC method as part of EIP-712.\\n *\\n * See {recover}.\\n */\\n function " + ], + [ + "mstore8(ptr, ", + "byte(mod(value, " + ], + [ + ".\\n * Use along with {balanceOf} to enumerate ", + "all of " + ], + [ + "`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool", + ");\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes calldata data\\n " + ], + [ + "ptr := add(buffer, ", + "add(32, length" + ], + [ + "owned by `owner` at a given `index` of its token list", + ".\\n * Use along with {balanceOf} to enumerate all of " + ], + [ + "term = ((term * x", + ") / ONE_20" + ], + [ + "));\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Typed Data, created from a\\n * `domainSeparator` and a `structHash`. This produces hash ", + "corresponding\\n * to the one signed with the\\n * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\\n * JSON-RPC method as part of EIP-712.\\n *\\n * See {recover}.\\n */\\n function " + ], + [ + "mstore8(ptr, byte(mod(value, ", + "10), _SYMBOLS" + ], + [ + "));\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Typed Data, created from a\\n * `domainSeparator` and a `structHash`. This produces hash corresponding\\n * to the one signed with the\\n * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\\n * JSON-RPC method as part of EIP-712.\\n *\\n * See {recover}.\\n */\\n function ", + "toTypedDataHash(bytes32 domainSeparator, bytes32 structHash" + ], + [ + "\"", + "AS" + ], + [ + "\"", + "node_modules/" + ], + [ + "&", + "%" + ], + [ + "'", + "if" + ], + [ + "D", + "utchAuction" + ], + [ + "F", + "ore" + ], + [ + "P", + "RE" + ], + [ + "S", + "G" + ], + [ + "U", + "Int" + ], + [ + "W", + "ol" + ], + [ + "[", + "_projectId" + ], + [ + "_", + "balanceOf" + ], + [ + "_", + "denominator" + ], + [ + "_", + "src" + ], + [ + "c", + "5" + ], + [ + "m", + "erk" + ], + [ + "s", + "or" + ], + [ + "u", + "ki" + ], + [ + "{", + "\\n\\n " + ], + [ + "}", + "\\n }" + ], + [ + "\\n ", + ");\\n\\n event " + ], + [ + "re", + "ator" + ], + [ + "to", + "," + ], + [ + "\\n ", + ");\\n " + ], + [ + ", ", + "address(0), " + ], + [ + ", ", + "adminRole" + ], + [ + "//", + " " + ], + [ + "es", + "tim" + ], + [ + ") ", + "<< " + ], + [ + "at", + "temp" + ], + [ + "token", + "ID" + ], + [ + "end", + " := " + ], + [ + "ic", + "al" + ], + [ + "to ", + "enable " + ], + [ + "owner", + "s" + ], + [ + "cont", + "roll" + ], + [ + "cont", + "ributor" + ], + [ + "Token", + "s = " + ], + [ + "Tr", + "ue " + ], + [ + "ERC20", + "Snapshot" + ], + [ + ".\\n *\\n * ", + "Documentation for signature generation:" + ], + [ + "(address ", + "pair, bool " + ], + [ + "data", + ", " + ], + [ + "Amount", + "Out" + ], + [ + ");\\n", + "}\"" + ], + [ + "), ", + "s" + ], + [ + "msgSender", + ";\\n emit OwnershipTransferred(address(0), msgSender" + ], + [ + ") external ", + "virtual " + ], + [ + "value ", + "- 1" + ], + [ + "that ", + "we " + ], + [ + "contract ", + "itself" + ], + [ + "max", + "Supply " + ], + [ + "max", + "Invocation" + ], + [ + "check", + "s that " + ], + [ + "min", + "ed" + ], + [ + "burn", + "ing " + ], + [ + "name", + "() external view returns (string memory" + ], + [ + "] ", + "<= " + ], + [ + "totalSupply", + "} to enumerate all " + ], + [ + "(\\n ", + "uint amountOut" + ], + [ + "swap", + "Amount" + ], + [ + "als", + "end" + ], + [ + "per", + "iphery" + ], + [ + "will ", + "be" + ], + [ + "interface", + ".\\n */\\n error " + ], + [ + "for", + "(uint256 " + ], + [ + "\\n ", + "// " + ], + [ + "\\n }\\n\\n function ", + "_" + ], + [ + "] = ", + "value" + ], + [ + "do", + "es " + ], + [ + "hash", + "ing " + ], + [ + ";\\n ", + "uint8 v" + ], + [ + "\"// SPDX-License-Identifier: MIT", + "\\n\\npragma solidity ^0.8." + ], + [ + "dead", + "Blocks" + ], + [ + "deleg", + "ated" + ], + [ + "00000000", + "0" + ], + [ + "00000000", + "00" + ], + [ + "================================", + "================================" + ], + [ + ")\\n ", + "result = " + ], + [ + "dis", + "allowed" + ], + [ + "sto", + "pped " + ], + [ + "block.timestamp", + " > " + ], + [ + "(address account", + ") public view returns (" + ], + [ + ",,", + "," + ], + [ + "ile ", + "@openzeppelin/contracts/" + ], + [ + "temp", + " := " + ], + [ + "SA", + "LE" + ], + [ + "minted ", + "must be " + ], + [ + "addition", + " of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add" + ], + [ + "_N", + "FT" + ], + [ + "MMMMMMMM", + "MMMM" + ], + [ + ".sol\\\";\\nimport \\\"./", + "IERC20" + ], + [ + "option", + "ally " + ], + [ + "doesn't ", + "perform any\\n * checks on the calling account.\\n *\\n * " + ], + [ + "collection", + "Size" + ], + [ + "[0", + "];\\n " + ], + [ + ") {\\n // ", + "On the first call to nonReentrant, _notEntered will be true" + ], + [ + ") external;\\n\\n /**\\n * @dev ", + "Safely transfers `tokenId` token from `from` to `to" + ], + [ + "spender` cannot be the zero address", + ".\\r\\n */\\r\\n function " + ], + [ + "\\\"\\n ", + ");\\n require(" + ], + [ + "Votes", + ": " + ], + [ + "addLiquidityETH", + "(\\n address token" + ], + [ + "--------------------------------", + "---------------" + ], + [ + "_packedOwnership", + "s[tokenId" + ], + [ + "ched", + "ule" + ], + [ + ");\\n }\\n\\n ", + "return (" + ], + [ + "/// @solidity memory-safe-assembly", + "\\n assembly {\\n " + ], + [ + "{\\n /**\\n * @dev ", + "Sets `value` as the allowance of `spender` " + ], + [ + "Interface", + "Implementer" + ], + [ + ";\\r\\n\\r\\n ", + "event " + ], + [ + ")) {\\n ", + " " + ], + [ + "ear", + "ly " + ], + [ + "' ", + "statement" + ], + [ + "))\\n ", + "s := mload(add(signature, 0x40" + ], + [ + ".\\n // ", + "- " + ], + [ + "other than ", + "the " + ], + [ + "V3", + " " + ], + [ + "Counters", + ".sol\"" + ], + [ + ".\\n */\\n function totalSupply() external view returns (uint256", + ");\\n\\n /**\\n * @dev Returns a token ID " + ], + [ + "PRO", + "V" + ], + [ + "b0", + "68" + ], + [ + "normalizedWeight", + "s" + ], + [ + "shr(", + "128" + ], + [ + "match", + "es " + ], + [ + "0.4.", + "24" + ], + [ + ".add(", + "amount);\\n " + ], + [ + "merkle ", + "tree" + ], + [ + "``role``'s admin role", + ".\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n " + ], + [ + "RAT", + "IO" + ], + [ + "treasury", + "Wallet" + ], + [ + "\\\\xe3\\\\x81", + "\\\\x8" + ], + [ + "AI", + "R" + ], + [ + "token id ", + "to " + ], + [ + "success ", + ":= " + ], + [ + "Active ", + "= false" + ], + [ + "----------------------------------------------------------------", + "-----------------------------------------------" + ], + [ + " ", + "| " + ], + [ + "resultPtr", + ", 1" + ], + [ + "a role's ", + "admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it" + ], + [ + "extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721", + "Enumerable is " + ], + [ + "IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, ", + "optional enumeration " + ], + [ + "```\\n * ", + "bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * " + ], + [ + "smart", + "-" + ], + [ + "BAS", + "E" + ], + [ + "}.\\n *\\n * Counterpart to Solidity's `", + "-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub" + ], + [ + "}.\\n *\\n * Counterpart to Solidity's `", + "%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod" + ], + [ + "tokens.\\n */\\n function ", + "tokenByIndex(uint256 index" + ], + [ + "stored by the contract", + ".\\n * Use along with {" + ], + [ + "modifi", + "ed " + ], + [ + "_PRIC", + "E" + ], + [ + "counter._value = ", + "value - 1" + ], + [ + "at a given `index` ", + "of all the tokens " + ], + [ + "bytes32 s", + ";\\n uint8 v" + ], + [ + "\\u0026\\u0026", + " " + ], + [ + "contract is not ", + "paused" + ], + [ + "Char", + "ity" + ], + [ + "in order ", + "to " + ], + [ + "admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {", + "_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role" + ], + [ + "a - b;\\n }\\n\\n /**\\n * @dev Returns the ", + "multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul" + ], + [ + "a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting ", + "when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod" + ], + [ + "))\\n v", + " := byte(0, mload(add(signature, 0x60" + ], + [ + ") {\\n bytes32 r;\\n ", + "bytes32 s;\\n uint8 v" + ], + [ + ")))\\n ", + "}\\n return " + ], + [ + ";\\n\\n _", + ";\\n\\n // " + ], + [ + "from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function ", + "_checkOnERC721Received" + ], + [ + "\\n require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED", + ";\\n\\n _;\\n\\n // " + ], + [ + "(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) public virtual override {\\n ", + "//solhint-disable-next-line max-line-length\\n require(" + ], + [ + "Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param ", + "from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received" + ], + [ + ") public returns (bool", + ");\\n function " + ], + [ + "Counter: decrement", + " overflow" + ], + [ + "total amount of tokens stored by the contract", + ".\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns a token ID " + ], + [ + "bytes4 retval) {\\n return retval == ", + "IERC721Receiver.onERC721Received.selector" + ], + [ + "2._\\n */\\n function ", + "recover" + ], + [ + "manu", + "alsend" + ], + [ + "signature.length == 65", + ") {\\n bytes32 r;\\n bytes32 s;\\n uint8 v" + ], + [ + "uint256 value = ", + "counter._value" + ], + [ + "value > 0, \\\"", + "Counter: decrement overflow" + ], + [ + "\\r\\n\\t\\tu", + "int " + ], + [ + "RoleRevoked(role, account, _msgSender()", + ");\\n }\\n }\\n}\\n\"" + ], + [ + ".\\n *\\n * See ", + "https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures" + ], + [ + ".sol@", + "v4." + ], + [ + "with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod", + "}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod" + ], + [ + "RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00", + ";\\n\\n /**\\n * @dev " + ], + [ + "Role(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ", + "``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n " + ], + [ + "account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function ", + "doesn't perform any\\n * checks on the calling account.\\n *\\n * " + ], + [ + "a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub", + "}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub" + ], + [ + "foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have ", + "a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it" + ], + [ + "Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ", + "```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * " + ], + [ + "} that receives the `r` and `vs` short-signature fields separately", + ".\\n *\\n * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures" + ], + [ + "\\n * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]", + "\\n * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers" + ], + [ + "(from, to, tokenId);\\n\\n // Clear approvals from the previous owner\\n _approve(address(0), tokenId);\\n\\n _balances[from] -= 1;\\n ", + "_balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer" + ], + [ + "div(a, b", + ", \\\"SafeMath: division by zero" + ], + [ + "`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes calldata data\\n ", + ") external;\\n}\\n\"" + ], + [ + "'if", + "' statement" + ], + [ + "Fore", + "ign" + ], + [ + ".\\n *\\n * Documentation for signature generation:", + "\\n * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\\n * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers" + ], + [ + "totalSupply} to enumerate all ", + "tokens.\\n */\\n function tokenByIndex(uint256 index" + ], + [ + ") {\\n // On the first call to nonReentrant, _notEntered will be true", + "\\n require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED;\\n\\n _;\\n\\n // " + ], + [ + "))\\n s := mload(add(signature, 0x40", + "))\\n v := byte(0, mload(add(signature, 0x60" + ], + [ + "stored by the contract.\\n * Use along with {", + "totalSupply} to enumerate all tokens.\\n */\\n function tokenByIndex(uint256 index" + ], + [ + "at a given `index` of all the tokens ", + "stored by the contract.\\n * Use along with {totalSupply} to enumerate all tokens.\\n */\\n function tokenByIndex(uint256 index" + ], + [ + "total amount of tokens stored by the contract.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns a token ID ", + "owned by `owner` at a given `index` of its token list.\\n * Use along with {balanceOf} to enumerate all of " + ], + [ + "Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ", + "```\\n * function " + ], + [ + "))\\n s := mload(add(signature, 0x40))\\n v := byte(0, mload(add(signature, 0x60", + ")))\\n }\\n return " + ], + [ + " ", + "\\n function " + ], + [ + ")", + "`, " + ], + [ + ")", + ");\\n " + ], + [ + ",", + "000" + ], + [ + "-", + "protocol/" + ], + [ + "0", + "7" + ], + [ + "1", + " to " + ], + [ + "7", + " " + ], + [ + "8", + "64" + ], + [ + ";", + "\\r\\n }\\r\\n " + ], + [ + "B", + "oughtEarly" + ], + [ + "C", + "au" + ], + [ + "D", + "76" + ], + [ + "M", + "sg" + ], + [ + "S", + "ample" + ], + [ + "S", + "ee: " + ], + [ + "S", + "niper" + ], + [ + "W", + "R" + ], + [ + "[", + "tx.origin" + ], + [ + "]", + "\\n * " + ], + [ + "_", + "pair" + ], + [ + "_", + "quantity" + ], + [ + "_", + "pause" + ], + [ + "_", + "MAX_MINT_ERC2309_QUANTITY_LIMIT" + ], + [ + "r", + " and `" + ], + [ + "}", + "\\n *\\n * _Available since v4.7._\\n */\\n function " + ], + [ + "\\n ", + " " + ], + [ + "to", + "\\r\\n * " + ], + [ + "ad", + "just" + ], + [ + ", ", + "un" + ], + [ + ", ", + "owner, " + ], + [ + ", ", + "AccessControl" + ], + [ + "return", + "\\n _" + ], + [ + ") ", + "/" + ], + [ + "token", + "Out" + ], + [ + "ER", + " " + ], + [ + "ERC", + "3525" + ], + [ + "To", + "Current" + ], + [ + ": ", + "expired " + ], + [ + ": ", + "do nothing" + ], + [ + "Re", + "ad" + ], + [ + "er ", + "The " + ], + [ + "ms", + "t" + ], + [ + " = ", + "192" + ], + [ + "bu", + "cket " + ], + [ + "data", + ".length" + ], + [ + "and ", + "is not " + ], + [ + "new", + "BaseURI" + ], + [ + "\\n ", + "string(\\n abi.encodePacked(" + ], + [ + "Address", + "(address " + ], + [ + "from ", + "== address(0)" + ], + [ + "add", + "ed" + ], + [ + "recipient", + ",\\r\\n uint256 amount\\r\\n " + ], + [ + "TH", + "E " + ], + [ + "error", + ": do nothing" + ], + [ + "> ", + "0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20" + ], + [ + "Approval", + "ToCurrent" + ], + [ + ");\\n\\n ", + "bool private " + ], + [ + " is ", + "missing role " + ], + [ + "Mint", + "ing " + ], + [ + ", \\\"", + "Must " + ], + [ + "swap", + "(" + ], + [ + ").", + "\\n // " + ], + [ + " ", + " " + ], + [ + "of the ", + "ECDSA signature " + ], + [ + "Swap", + " " + ], + [ + "tokens", + "Owed" + ], + [ + "buy", + "DevelopmentFee" + ], + [ + "(_", + "account" + ], + [ + "amount ", + "<= _" + ], + [ + "sell", + "DevelopmentFee" + ], + [ + "main", + "Balance" + ], + [ + "fee", + "Bps" + ], + [ + "user", + "s " + ], + [ + "error ", + "string. This " + ], + [ + " - ", + "`" + ], + [ + "ERC721A", + "Common" + ], + [ + "} el", + "se " + ], + [ + "MIN", + "_" + ], + [ + "unchecked {\\n ", + "counter._value " + ], + [ + ") internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(", + "uint," + ], + [ + "mapping(address => ", + "mapping(address => uint256" + ], + [ + "library ", + "SafeMath" + ], + [ + "type(", + "int256" + ], + [ + " ", + " " + ], + [ + "withdraw", + "(" + ], + [ + "gu", + "ard " + ], + [ + "((", + "(" + ], + [ + "assembly {", + "\\r\\n " + ], + [ + "Col", + "or" + ], + [ + "signer", + " == address(0)" + ], + [ + "_data", + "` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer" + ], + [ + "disable", + "TransferDelay" + ], + [ + "A ", + "record of " + ], + [ + "leaf", + ", " + ], + [ + "(\\n uint256 ", + "_editionId" + ], + [ + "(address(0), to, ", + "tokenId, _data" + ], + [ + "_holder", + "Tokens" + ], + [ + "} from \\\"", + "@" + ], + [ + "Cur", + "ve" + ], + [ + "base ", + "URI" + ], + [ + "() external view returns (uint256", + ");\\n\\n function " + ], + [ + "Withdraw", + "Request" + ], + [ + "permission", + "ed " + ], + [ + "\\r\\n * ", + "- " + ], + [ + "\\\");\\n unchecked {\\n ", + "counter._value = value - 1" + ], + [ + "EIP-", + "712 " + ], + [ + "for (uint256 i = 0; i", + " < _" + ], + [ + "}\\n }\\n\\n function ", + "decrement(Counter storage counter) internal {\\n " + ], + [ + "let", + "ree" + ], + [ + "x ", + "& 0x" + ], + [ + "sti", + "tu" + ], + [ + "random", + "ness" + ], + [ + "``owner``'s ", + "tokens.\\n */\\n function tokenOfOwnerByIndex(address owner, uint256 index" + ], + [ + "create ", + "new " + ], + [ + "avoid", + "able" + ], + [ + "_owners[tokenId", + "];\\n require(" + ], + [ + "Math.", + "log256(value) + " + ], + [ + "Math.", + "log10(value) + " + ], + [ + "\"log(", + "uint256," + ], + [ + "circ", + "ul" + ], + [ + "known ", + "as " + ], + [ + ", bytes memory ", + "_data" + ], + [ + ";\\n require(", + "value > 0, \\\"Counter: decrement overflow" + ], + [ + "Initializable", + ": " + ], + [ + "══", + "══" + ], + [ + "development", + "Fee" + ], + [ + "USD", + "T" + ], + [ + "error == ", + "RecoverError.NoError" + ], + [ + "} that receives the `", + "r and `" + ], + [ + "RecoverError error", + ") private pure " + ], + [ + ")\\\", p0, p1, p2));\\n\\t}\\n\\n\\tfunction log(", + "uint " + ], + [ + "throwError(", + "RecoverError error) private pure " + ], + [ + "dou", + "ble " + ], + [ + "(address(0), RecoverError.InvalidSignature", + "S" + ], + [ + "(address(0), RecoverError.InvalidSignature", + "Length" + ], + [ + "Ea", + "rn" + ], + [ + "` or ", + "error string. This " + ], + [ + "toHexString(value, ", + "Math.log256(value) + " + ], + [ + "Star", + "ting" + ], + [ + "▒▒▒▒", + "▒▒▒▒" + ], + [ + "Lz", + "Receive" + ], + [ + "artblocks", + "PrimarySales" + ], + [ + " =\\n ", + "keccak256(\\\"" + ], + [ + "(IERC20 token", + ", address " + ], + [ + "entially ", + "a " + ], + [ + "Off", + "set " + ], + [ + "Tw", + "o" + ], + [ + "length = ", + "Math.log10(value) + " + ], + [ + "address payable", + ") {\\n return " + ], + [ + "TRANSFER", + "S" + ], + [ + "_balances[account] = _balances[account", + "].add(amount);\\n emit Transfer" + ], + [ + "RoleAdminChanged(", + "role" + ], + [ + "Without", + "Fee" + ], + [ + ";\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual ", + "override(ERC165, IERC165) returns (bool) {\\n return\\n interfaceId == type(IERC721).interfaceId ||\\n interfaceId == type(IERC721Metadata).interfaceId ||\\n super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner" + ], + [ + "(30", + "1): 0 < s < secp256k1n ÷ 2 + 1, and for v in " + ], + [ + ">`\\n * - `", + "startTimestamp = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20" + ], + [ + "effici", + "ency " + ], + [ + "\\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner", + "\\\");\\n\\n require(\\n _msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: " + ], + [ + "signer, ", + "RecoverError.NoError" + ], + [ + "; // no ", + "error: do nothing" + ], + [ + "_owners[tokenId] != ", + "address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n " + ], + [ + "math/Math.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n enum Rounding {\\n Down, // Toward negative infinity\\n Up, // Toward infinity\\n Zero // Toward zero\\n }\\n\\n /**\\n * @dev Returns the largest of two numbers.\\n */\\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a ", + "> b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2;\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute.\\n return a == 0 ? 0 : (a - 1) / b + 1;\\n }\\n\\n /**\\n * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\\n * with further edits by Uniswap Labs also under MIT license" + ], + [ + "), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return ", + "_owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n " + ], + [ + "multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul", + "(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n " + ], + [ + "IERC721.sol\\\";\\nimport \\\"./IERC721Receiver.sol\\\";\\nimport \\\"./extensions/IERC721Metadata", + ".sol\\\";\\nimport \\\"../../utils/Address.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\nimport \\\"../../utils/Strings.sol\\\";\\nimport \\\"../../utils/introspection/ERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721 is Context, ERC165, IERC721, IERC721Metadata {\\n using Address for address;\\n using Strings for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address" + ], + [ + ");\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n ", + "delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId" + ], + [ + "merk", + "letree" + ], + [ + ")\\n result = ", + "result * " + ], + [ + "uint256 value = counter._value", + ";\\n require(value > 0, \\\"Counter: decrement overflow" + ], + [ + "Foreign", + "Token" + ], + [ + "of the ECDSA signature ", + "pair" + ], + [ + "} that receives the `r and `", + "vs` short-signature fields separately" + ], + [ + "(301): 0 < s < secp256k1n ÷ 2 + 1, and for v in ", + "(30" + ], + [ + "Wrappers over Solidity's arithmetic operations with added overflow\\n * checks.\\n *\\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\\n * in bugs, because programmers usually assume that an overflow raises an\\n * error, which is the standard behavior in high level programming languages.\\n * `SafeMath` restores this intuition by reverting the transaction when an\\n * ", + "operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it alway" + ], + [ + "slippage is un", + "avoidable" + ], + [ + "+= 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n ", + "uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow" + ], + [ + "Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value ", + "+= 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow" + ], + [ + "Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow", + "\\\");\\n unchecked {\\n counter._value = value - 1" + ], + [ + "'", + "given " + ], + [ + ")", + "\\n " + ], + [ + ")", + "\\n {\\n " + ], + [ + "-", + "value " + ], + [ + "0", + ";\\n }\\n}\\n\"" + ], + [ + "1", + "be" + ], + [ + "?", + "?" + ], + [ + "A", + "0) {\\n return " + ], + [ + "E", + "sc" + ], + [ + "E", + "ach" + ], + [ + "F", + "ic" + ], + [ + "L", + "en" + ], + [ + "L", + "eg" + ], + [ + "L", + "isting" + ], + [ + "M", + "atch" + ], + [ + "M", + "ET" + ], + [ + "P", + "ot" + ], + [ + "_", + "round" + ], + [ + "_", + "list" + ], + [ + "`", + "_from" + ], + [ + "`", + ".\\n */\\n event " + ], + [ + "c", + "ast " + ], + [ + "e", + ", " + ], + [ + "f", + "its " + ], + [ + "l", + "itt" + ], + [ + "o", + "nt" + ], + [ + "{", + "\\n // " + ], + [ + "}", + "\\n " + ], + [ + "\\n ", + ") external view returns (" + ], + [ + "e ", + "in " + ], + [ + "in", + "correctly " + ], + [ + "return", + "ed by " + ], + [ + "token", + ", " + ], + [ + "\\n ", + "(" + ], + [ + "amount", + "s, " + ], + [ + "ver", + "se " + ], + [ + ") {", + "\\n // " + ], + [ + ") {", + " break" + ], + [ + "ma", + "j" + ], + [ + "Re", + "fer" + ], + [ + "Tr", + "usted" + ], + [ + "value", + ");\\n " + ], + [ + "return ", + "false" + ], + [ + ",\\n ", + "uint256[] calldata " + ], + [ + ". ", + "See " + ], + [ + "wh", + "ile the " + ], + [ + "index", + "Of" + ], + [ + "ting", + " to " + ], + [ + "mo", + "de" + ], + [ + "private ", + "constant " + ], + [ + "), ", + "'" + ], + [ + "), ", + "32" + ], + [ + "mint", + "ed in " + ], + [ + "zero ", + "address" + ], + [ + "Ex", + "tra" + ], + [ + "token ", + "owner " + ], + [ + "IERC20", + " {" + ], + [ + "check", + "TxLimit" + ], + [ + "IT", + "E" + ], + [ + "balances", + ".length" + ], + [ + "0.", + "_" + ], + [ + "] ", + "private " + ], + [ + "0x", + "6" + ], + [ + "id", + "s.length" + ], + [ + "IERC721", + ".onERC721Received.selector`.\\n */\\n function onERC721Received(\\n address operator,\\n address from,\\n uint256 tokenId,\\n bytes calldata data\\n ) external returns (bytes4);\\n}\\n\"" + ], + [ + "pre", + "JoinExitInvariant" + ], + [ + "{\\n ", + "require(" + ], + [ + "EIP", + " " + ], + [ + ";\\n ", + "uint256 internal " + ], + [ + "\\n */\\n function ", + "toUint" + ], + [ + "https://", + "forum." + ], + [ + "s to ", + "normal " + ], + [ + "....", + "." + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `", + "receiver` cannot be the zero address.\\n * - `feeNumerator` cannot be greater than the fee denominator.\\n */\\n function _set" + ], + [ + "recei", + "ved" + ], + [ + "deadline", + ", uint8 v, bytes32 r, bytes32 s" + ], + [ + "Counter", + "s {\\n struct " + ], + [ + ", and ", + "may " + ], + [ + "96", + "96" + ], + [ + "_isExcludedFrom", + "MaxWalletLimit" + ], + [ + "read", + " and " + ], + [ + "last", + "Value" + ], + [ + "s are ", + "made " + ], + [ + "update", + "MarketingWallet" + ], + [ + "(address account", + ", bool " + ], + [ + "temp", + "Bytes" + ], + [ + "minted ", + "at " + ], + [ + "ROLE", + "_" + ], + [ + "claim", + "ed " + ], + [ + "MAX", + "_P" + ], + [ + "when", + "Paused(" + ], + [ + "Lock", + "ed(" + ], + [ + "████", + "███" + ], + [ + "maximum", + " of " + ], + [ + "\"Address: ", + "static " + ], + [ + "ed, ", + "decrement" + ], + [ + "router", + "V2" + ], + [ + "same ", + "storage slot" + ], + [ + "Ext", + "ernal" + ], + [ + "{\\n // ", + "Ensure the " + ], + [ + "\"@openzeppelin/contracts/utils/", + "Counters.sol\"" + ], + [ + "math/", + "SignedMath" + ], + [ + "Mod", + "ifi" + ], + [ + "),", + "\\n " + ], + [ + "once ", + "the " + ], + [ + "_un", + "pause" + ], + [ + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./", + "math/Math" + ], + [ + "mapping(address => bool", + ") private " + ], + [ + "\\u003c", + " " + ], + [ + ") private {\\n ", + "if (" + ], + [ + "manual", + "swap" + ], + [ + "Add ", + "the " + ], + [ + "(address from, address to, uint256 amount", + ") internal virtual { " + ], + [ + "$$$$", + "$$" + ], + [ + ".\\n // ", + "This " + ], + [ + "buyback", + "Fee" + ], + [ + ".\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_", + ";\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\\n return\\n interfaceId == type(IERC721).interfaceId ||\\n interfaceId == type(IERC721Metadata).interfaceId ||\\n super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner" + ], + [ + ",\\n address indexed ", + "to" + ], + [ + "FRAX", + "." + ], + [ + " TH", + "E " + ], + [ + ">> 128", + ";\\n if (" + ], + [ + "(from, to, tokenId, _data", + ");\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `" + ], + [ + ");\\r\\n ", + "\\r\\n " + ], + [ + "_approve(_msgSender(), spender, _allowances[_msgSender()][spender", + "] + " + ], + [ + "\"Cannot set ", + "max " + ], + [ + "expres", + "s" + ], + [ + "entri", + "es." + ], + [ + "TokenOwnership memory ownership", + " = " + ], + [ + "uint256 new", + "Allowance = token.allowance(address(this), spender" + ], + [ + "_balances[account] = _balances[account", + "].sub(amount, \\\"ERC20: burn " + ], + [ + "ed or ", + "reset" + ], + [ + "Interest", + "Rate" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover", + "} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n */\\n function recover" + ], + [ + "Before ", + "= " + ], + [ + ");\\n _owner = ", + "msgSender;\\n emit OwnershipTransferred(address(0), msgSender" + ], + [ + "abi.decode(", + "returndata" + ], + [ + ");\\n\\n /**\\n * @dev Revert with an error ", + "if " + ], + [ + "uniswapV2Router ", + "= IUniswapV2Router02" + ], + [ + ")\\n internal\\n pure", + "\\n returns (" + ], + [ + "query the ", + "balance for " + ], + [ + "_adapter", + "Params" + ], + [ + "Rang", + "e(" + ], + [ + "_addressData[to].", + "balance " + ], + [ + "while (true", + ") {\\n " + ], + [ + "grou", + "p" + ], + [ + "APPRO", + "VAL" + ], + [ + ",\\n address to,\\n uint256 value\\n ) internal {\\n ", + "_callOptionalReturn(token, abi.encodeWithSelector(token." + ], + [ + "equals ", + "1" + ], + [ + "\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = ", + "_owners[tokenId];\\n require(" + ], + [ + "EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\\n // the valid range for s in ", + "(301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (30" + ], + [ + "Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer", + "(address sender, address recipient, uint256 amount" + ], + [ + "s `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n ", + "_balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer" + ], + [ + "Extension of {ERC20} that allows token holders to destroy both their own\\n * tokens and those that they have an allowance for, in a way that can be\\n * recognized off-chain (via event analysis).\\n */\\nabstract contract ERC20Burnable is Context, ERC20", + " {\\n /**\\n * @dev " + ], + [ + "ele", + "gram" + ], + [ + "shifted by ", + "an " + ], + [ + "Ter", + "m" + ], + [ + "Destin", + "ation" + ], + [ + "IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional enumeration ", + "extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Enumerable is " + ], + [ + "total amount of tokens stored by the contract.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns a token ID owned by `owner` at a given `index` of its token list.\\n * Use along with {balanceOf} to enumerate all of ", + "``owner``'s tokens.\\n */\\n function tokenOfOwnerByIndex(address owner, uint256 index" + ], + [ + ": expired ", + "deadline" + ], + [ + ". This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary ", + "Counters {\\n struct " + ], + [ + "Esc", + "row" + ], + [ + ") { break", + " " + ], + [ + "\"Address: static ", + "call to non-contract\"" + ], + [ + "ed, decrement", + "ed or reset" + ], + [ + ".\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\\n return\\n interfaceId == type(IERC721).interfaceId ||\\n interfaceId == type(IERC721Metadata).interfaceId ||\\n super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner", + ") public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: " + ], + [ + ">> 128;\\n if (", + "x & 0x" + ], + [ + "(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `", + "_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer" + ], + [ + "\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(", + "owner != address(0), \\\"ERC721: " + ], + [ + "EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\\n // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (30", + "2): v ∈ {27, 28}. Most\\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\\n //\\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\\n // these malleable signatures as well" + ], + [ + ". This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct ", + "Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1" + ], + [ + "(", + "2" + ], + [ + "(", + ") private {\\n // " + ], + [ + "5", + "1" + ], + [ + "A", + "MP" + ], + [ + "A", + "X96" + ], + [ + "B", + "in" + ], + [ + "F", + "Y" + ], + [ + "G", + "DC" + ], + [ + "L", + "ATER" + ], + [ + "O", + "therwise" + ], + [ + "P", + "ire" + ], + [ + "S", + ",\\n InvalidSignature" + ], + [ + "S", + ") {\\n revert(\\\"ECDSA: invalid signature " + ], + [ + "Y", + "our " + ], + [ + "]", + ",\\\"" + ], + [ + "_", + "MINT" + ], + [ + "_", + "nonces" + ], + [ + "`", + "addr" + ], + [ + "l", + "aim" + ], + [ + "s", + "ac" + ], + [ + "t", + "Burn" + ], + [ + "x", + "/" + ], + [ + " ", + "`" + ], + [ + "\\n", + "\\n " + ], + [ + "to", + "Swap" + ], + [ + "\\n ", + "} else if (error == RecoverError.InvalidSignature" + ], + [ + "uint", + "48" + ], + [ + ") ", + "||\\n " + ], + [ + "` ", + "methods." + ], + [ + "be ", + "called by " + ], + [ + "\\n * ", + "and " + ], + [ + "spender", + " The " + ], + [ + ". ", + "See {" + ], + [ + "at ", + "any " + ], + [ + "set", + "(" + ], + [ + "{\\n ", + "NoError" + ], + [ + "sender", + ",\\r\\n address " + ], + [ + "max", + "TokenId" + ], + [ + ").", + "add(" + ], + [ + " * ", + "10 ** " + ], + [ + "Rol", + "es: " + ], + [ + "\\n // ", + "and " + ], + [ + "id", + "To" + ], + [ + "\\\");\\n ", + "}\\n }\\n\\n /**\\n * @dev Returns the " + ], + [ + "Math", + ".mul(" + ], + [ + "do", + "-" + ], + [ + "ERC165", + "Storage" + ], + [ + ";\\n ", + "/// @solidity memory-safe-assembly\\n assembly {\\n " + ], + [ + "\"// SPDX-License-Identifier: MIT", + "\\r\\n\\r\\n" + ], + [ + "eg", + "gs" + ], + [ + "which ", + "allows " + ], + [ + "\\r\\n ", + "if (" + ], + [ + "+= ", + "uint64(" + ], + [ + "_mint", + "ed" + ], + [ + "call ", + "or " + ], + [ + "base", + "64" + ], + [ + " - ", + "1;\\n " + ], + [ + "later", + ".\\n let " + ], + [ + ">> ", + "8" + ], + [ + ";\\n ", + "if (" + ], + [ + ";\\n ", + "if (value == 0) break" + ], + [ + ") internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(", + "bool," + ], + [ + "And", + "Send" + ], + [ + "amountETH", + "Marketing" + ], + [ + "transfer to ", + "a contract " + ], + [ + "reverting ", + "on\\r\\n * overflow" + ], + [ + "IUniswapV2Router0", + "1 " + ], + [ + " bits", + "\\r\\n *\\r\\n * " + ], + [ + "88", + "88" + ], + [ + "_buy", + "Fee" + ], + [ + "_buy", + "DevFee" + ], + [ + "() external ", + "onlyOwner " + ], + [ + "inter", + "val" + ], + [ + ";\\n }\\n ", + "return buffer" + ], + [ + "Length", + ",\\n InvalidSignature" + ], + [ + "Length", + ") {\\n revert(\\\"ECDSA: invalid signature length" + ], + [ + "safeMint", + "(address to, uint256 quantity" + ], + [ + "Address ", + "== " + ], + [ + "Address ", + "!= " + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (", + "utils/Strings.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary Strings {\\n bytes16 private constant _HEX_SYMBOLS = \\\"0123456789abcdef\\\";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n // Inspired by OraclizeAPI's implementation - MIT licence\\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\\n\\n if (value == 0) {\\n return \\\"0\\\";\\n }\\n uint256 temp = value;\\n uint256 digits;\\n while (temp != 0) {\\n digits++;\\n temp /= 10;\\n }\\n bytes memory buffer = new bytes(digits);\\n while (value != 0) {\\n digits -= 1;\\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\\n value /= 10;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n if (value == 0) {\\n return \\\"0x00\\\";\\n }\\n uint256 temp = value;\\n uint256 length = 0;\\n while (temp != 0) {\\n length++;\\n temp >>= 8;\\n }\\n return toHexString(value, length);\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = _HEX_SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n}\\n\"" + ], + [ + "delegate ", + "to " + ], + [ + "let ", + "temp := " + ], + [ + "████", + "▌" + ], + [ + "ed = ", + "false" + ], + [ + "Public", + "Mint" + ], + [ + "an address ", + "and is not " + ], + [ + "1;\\n ", + "string memory buffer = new string(length" + ], + [ + ") public view returns (", + "uint256) {\\n return " + ], + [ + "-= ", + "x" + ], + [ + "15", + " " + ], + [ + "Exceed", + "ed\"" + ], + [ + "max ", + "supply" + ], + [ + " (when the ", + "input is " + ], + [ + "request", + "." + ], + [ + ") external returns (", + "address pair" + ], + [ + "ptr", + "--;\\n " + ], + [ + "ptr", + ";\\n /// @solidity memory-safe-assembly\\n assembly {\\n " + ], + [ + ");\\n if (", + "signer == address(0)" + ], + [ + "____", + "____" + ], + [ + "}\\n ", + "value /= 10" + ], + [ + "] = true", + ";\\n emit " + ], + [ + "_holderLastTransferTimestamp", + "[tx.origin" + ], + [ + ") private view returns (", + "bool) {\\n return " + ], + [ + "}\\n }\\n\\n ", + "/// @dev " + ], + [ + " ", + "* " + ], + [ + ".\\n *\\n * _Available since v4.", + "2._\\n */\\n function recover" + ], + [ + "))\\n ", + "}\\n value /= 10" + ], + [ + "/* ", + "solhint-disable " + ], + [ + "more than ", + "zero" + ], + [ + "(\\r\\n address ", + "token" + ], + [ + "70", + "E" + ], + [ + "HEX", + "Stake" + ], + [ + ", uint amount", + "0, uint amount1" + ], + [ + "Converts a `uint256` to its ASCII `string` hexadecim", + "al representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n " + ], + [ + "Converts a `uint256` to its ASCII `string` hexadecim", + "al representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i" + ], + [ + ");\\n }\\n ", + "_" + ], + [ + "(uint256 _", + "pid" + ], + [ + "OPERATOR_FILTER_REGISTRY", + ").code.length" + ], + [ + " betwe", + "en " + ], + [ + "It", + "'s " + ], + [ + "sequ", + "ence " + ], + [ + "RecoverError ", + "{\\n NoError" + ], + [ + "merkle ", + "tree " + ], + [ + "AccessControl: ", + "account " + ], + [ + "O(1", + "), " + ], + [ + "reser", + "ved" + ], + [ + "reset", + "(Counter storage counter) internal {\\n " + ], + [ + ".\\n if (", + "uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20" + ], + [ + "Address, ", + "uint64 _" + ], + [ + "(uint256 value) internal pure returns (string memory) {\\n ", + "unchecked {\\n uint256 " + ], + [ + "proposal", + "." + ], + [ + ");\\n }\\n }\\n\\n /**\\n * @dev Returns the ", + "address that signed a hashed message (`hash`) with\\n * `signature`. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it.\\n */\\n function recover(bytes32 hash, bytes memory signature" + ], + [ + ";\\n\\nimport '", + "@openzeppelin/contracts/" + ], + [ + ") {\\n revert(\\\"", + "ECDSA: invalid signature" + ], + [ + ",\\n InvalidSignature", + ",\\n InvalidSignature" + ], + [ + "{\\n if (", + "error == RecoverError.NoError" + ], + [ + "_exists(tokenId), \\\"ERC721: ", + "operator query for nonexistent token" + ], + [ + "refund", + "Address" + ], + [ + "Equivalent to `", + "_burn(tokenId, false" + ], + [ + "Equivalent to `", + "_safeMint(to, quantity, ''" + ], + [ + ".\\n *\\n * _Available since v4.3._\\n */\\n function ", + "tryRecover" + ], + [ + "if (a ", + "== 0" + ], + [ + ";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString", + "(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n uint256 " + ], + [ + "Struc", + "t" + ], + [ + "64.", + "64" + ], + [ + "tryRecover(hash, v, r, s", + ");\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev " + ], + [ + "tryRecover(hash, v, r, s", + ");\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover" + ], + [ + ") internal pure returns (address, RecoverError", + ") {\\n bytes32 " + ], + [ + ") internal pure returns (address) {\\n (address recovered, RecoverError error) = ", + "tryRecover(hash, v, r, s);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev " + ], + [ + "digit", + "s (" + ], + [ + "pointer", + ", " + ], + [ + "have", + "Right" + ], + [ + "leaf ", + "value" + ], + [ + ");\\n }\\n\\n // ", + "If the signature is valid (and not malleable), return the signer address\\n address signer = ecrecover(hash, v, r, s" + ], + [ + "administr", + "ator " + ], + [ + ", signature", + ");\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover" + ], + [ + "if (b == 0", + ") return (false, 0);\\n return (true, " + ], + [ + "IDEX", + "Factory" + ], + [ + "\\\");\\n } else if (error == RecoverError.InvalidSignature", + "S) {\\n revert(\\\"ECDSA: invalid signature " + ], + [ + "\\\");\\n } else if (error == RecoverError.InvalidSignature", + "Length) {\\n revert(\\\"ECDSA: invalid signature length" + ], + [ + ") return (false, 0);\\n return (true, ", + "c" + ], + [ + "\\n * ", + " - `" + ], + [ + "returndatasize())", + "\\n " + ], + [ + ";\\n }\\n }\\n\\n function ", + "reset(Counter storage counter) internal {\\n " + ], + [ + "mapping (address => bool", + ") private " + ], + [ + "address that signed a hashed message (`hash`) with\\n * `signature", + "` or error string. This " + ], + [ + "address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it", + ".\\n *\\n * Documentation for signature generation:\\n * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\\n * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers" + ], + [ + "_RAT", + "IO" + ], + [ + "} that receives the `v`,\\n * `r` and `s` signature fields separately", + ".\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover" + ], + [ + ");\\n uint256 ", + "ptr;\\n /// @solidity memory-safe-assembly\\n assembly {\\n " + ], + [ + ") internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash", + ", r, vs" + ], + [ + ") internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash", + ", signature);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover" + ], + [ + ");\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover", + "} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover" + ], + [ + "]\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover", + "(bytes32 hash, bytes memory signature" + ], + [ + "safely ", + "transfer to a contract " + ], + [ + "` operator.\\r\\n *\\r\\n * Requirements:\\r\\n *\\r\\n * - ", + "input must fit into " + ], + [ + "_INTERFACE_ID_", + "ERC721" + ], + [ + "token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all", + ".\\n */\\ninterface IERC20" + ], + [ + ") {\\n return (address(0), RecoverError.InvalidSignature", + ");\\n }\\n\\n return (" + ], + [ + "\\\";\\n uint8 private constant _ADDRESS_LENGTH = 20", + ";\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n uint256 " + ], + [ + ") {\\n return", + "; // no error: do nothing" + ], + [ + ") internal pure returns (address, RecoverError) {\\n // ", + "EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\\n // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\\n //\\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\\n // these malleable signatures as well" + ], + [ + "on its ", + "behalf" + ], + [ + "(address indexed sender", + ", uint amount0, uint amount1" + ], + [ + "_toString", + "(tokenId))" + ], + [ + "So", + "me" + ], + [ + ");\\n } else {\\n return ", + "(address(0), RecoverError.InvalidSignatureLength" + ], + [ + "\"// SPDX-License-Identifier: GPL-2.0-or-later", + "\\npragma solidity >=" + ], + [ + "IPancake", + "V3" + ], + [ + "SafeTransfer", + "Lib" + ], + [ + "DECIMAL", + "S" + ], + [ + "byp", + "ass " + ], + [ + "lower than 0.001", + "% total supply.\"" + ], + [ + "address msgSender = _msgSender(", + ");\\n _owner = msgSender;\\n emit OwnershipTransferred(address(0), msgSender" + ], + [ + "__gap", + ";\\n}\\n\"" + ], + [ + "senderBalance = _balances[sender", + "];\\n require(" + ], + [ + "1);\\n }\\n }\\n\\n /**\\n * @dev ", + "Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i" + ], + [ + "quantity of tokens ", + "minted must be " + ], + [ + "(\\n Swap", + "Request memory " + ], + [ + "Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be increment", + "ed, decremented or reset" + ], + [ + "VRFConsumer", + "Base" + ], + [ + "_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev ", + "Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account" + ], + [ + "))\\n }\\n ", + "while (true) {\\n " + ], + [ + "5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a4", + "70" + ], + [ + "non-reverting call", + "s are " + ], + [ + "] = _SYMBOLS", + "[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer" + ], + [ + ".sol\\u0027;\\n", + "import \\u0027./" + ], + [ + "SYMBOLS = \\\"0123456789abcdef", + "\\\";\\n uint8 private constant _ADDRESS_LENGTH = 20;\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n uint256 " + ], + [ + "ptr := add(buffer, add(32, length", + "))\\n }\\n while (true) {\\n " + ], + [ + "mstore8(ptr, byte(mod(value, 10), _SYMBOLS", + "))\\n }\\n value /= 10" + ], + [ + "\"AS", + "AP" + ], + [ + "\\n }\\n\\n function _", + "throwError(RecoverError error) private pure " + ], + [ + "/// @solidity memory-safe-assembly\\n assembly {\\n ", + "mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n }\\n value /= 10" + ], + [ + "foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it", + ".\\n */\\nabstract contract AccessControl" + ], + [ + "} that receives the `r` and `vs` short-signature fields separately.\\n *\\n * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures", + "]\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover" + ], + [ + "at a given `index` of all the tokens stored by the contract.\\n * Use along with {totalSupply} to enumerate all tokens.\\n */\\n function tokenByIndex(uint256 index", + ") external view returns (uint256);\\n}\\n\"" + ], + [ + "Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function ", + "foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControl" + ], + [ + "))\\n s := mload(add(signature, 0x40))\\n v := byte(0, mload(add(signature, 0x60)))\\n }\\n return ", + "tryRecover(hash, v, r, s" + ], + [ + "signer, RecoverError.NoError", + ");\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n */\\n function recover" + ], + [ + ")\\n result = result * ", + "0x" + ], + [ + "} that receives the `r and `vs` short-signature fields separately", + ".\\n *\\n * _Available since v4.2._\\n */\\n function recover" + ], + [ + "A0) {\\n return ", + "(address(0), RecoverError.InvalidSignatureS" + ], + [ + "LATER", + "AL" + ], + [ + "S,\\n InvalidSignature", + "V" + ], + [ + "\\n } else if (error == RecoverError.InvalidSignature", + ") {\\n revert(\\\"ECDSA: invalid signature" + ], + [ + "\\\");\\n }\\n }\\n\\n /**\\n * @dev Returns the ", + "address that signed a hashed message (`hash`) with\\n * `signature` or error string. This " + ], + [ + "+= uint64(", + "quantity" + ], + [ + ";\\n if (value == 0) break", + ";\\n }\\n return buffer" + ], + [ + "reverting on\\r\\n * overflow", + " (when the input is " + ], + [ + "Length,\\n InvalidSignature", + "S,\\n InvalidSignatureV" + ], + [ + "1;\\n string memory buffer = new string(length", + ");\\n uint256 ptr;\\n /// @solidity memory-safe-assembly\\n assembly {\\n " + ], + [ + "ptr--;\\n ", + "/// @solidity memory-safe-assembly\\n assembly {\\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n }\\n value /= 10" + ], + [ + ");\\n if (signer == address(0)", + ") {\\n return (address(0), RecoverError.InvalidSignature);\\n }\\n\\n return (" + ], + [ + "Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n ", + "unchecked {\\n return " + ], + [ + "RecoverError {\\n NoError", + ",\\n InvalidSignature,\\n InvalidSignature" + ], + [ + ".\\n if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20", + "A0) {\\n return (address(0), RecoverError.InvalidSignatureS" + ], + [ + ");\\n }\\n }\\n\\n /**\\n * @dev Returns the address that signed a hashed message (`hash`) with\\n * `signature`. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it.\\n */\\n function recover(bytes32 hash, bytes memory signature", + ") internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, signature);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover" + ], + [ + "{\\n if (error == RecoverError.NoError", + ") {\\n return; // no error: do nothing" + ], + [ + "tryRecover(hash, v, r, s);\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover", + "} that receives the `r and `vs` short-signature fields separately.\\n *\\n * _Available since v4.2._\\n */\\n function recover" + ], + [ + ") internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, v, r, s);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev ", + "Returns an Ethereum Signed Message, created from a `hash`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash" + ], + [ + ");\\n }\\n\\n // If the signature is valid (and not malleable), return the signer address\\n address signer = ecrecover(hash, v, r, s", + ");\\n if (signer == address(0)) {\\n return (address(0), RecoverError.InvalidSignature);\\n }\\n\\n return (" + ], + [ + "\\\");\\n } else if (error == RecoverError.InvalidSignatureS) {\\n revert(\\\"ECDSA: invalid signature ", + "'s' value" + ], + [ + "\\\");\\n } else if (error == RecoverError.InvalidSignatureLength) {\\n revert(\\\"ECDSA: invalid signature length", + "\\\");\\n } else if (error == RecoverError.InvalidSignatureS) {\\n revert(\\\"ECDSA: invalid signature 's' value" + ], + [ + ";\\n }\\n }\\n\\n function reset(Counter storage counter) internal {\\n ", + "counter._value = " + ], + [ + "address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it.\\n *\\n * Documentation for signature generation:\\n * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\\n * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers", + "]\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover(bytes32 hash, bytes memory signature" + ], + [ + ") internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, r, vs", + ");\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover" + ], + [ + "safely transfer to a contract ", + "that does not " + ], + [ + ") internal pure returns (address, RecoverError) {\\n // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\\n // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\\n //\\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\\n // these malleable signatures as well", + ".\\n if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\\n return (address(0), RecoverError.InvalidSignatureS" + ], + [ + ");\\n } else {\\n return (address(0), RecoverError.InvalidSignatureLength", + ");\\n }\\n }\\n\\n /**\\n * @dev Returns the address that signed a hashed message (`hash`) with\\n * `signature`. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it.\\n */\\n function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, signature);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover" + ], + [ + "1);\\n }\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i", + "] = _SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer" + ], + [ + "quantity of tokens minted must be ", + "more than zero" + ], + [ + "ptr := add(buffer, add(32, length))\\n }\\n while (true) {\\n ", + "ptr--;\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n }\\n value /= 10" + ], + [ + "\\n }\\n\\n function _throwError(RecoverError error) private pure ", + "{\\n if (error == RecoverError.NoError) {\\n return; // no error: do nothing" + ], + [ + "\\n } else if (error == RecoverError.InvalidSignature) {\\n revert(\\\"ECDSA: invalid signature", + "\\\");\\n } else if (error == RecoverError.InvalidSignatureLength) {\\n revert(\\\"ECDSA: invalid signature length\\\");\\n } else if (error == RecoverError.InvalidSignatureS) {\\n revert(\\\"ECDSA: invalid signature 's' value" + ], + [ + "\\\");\\n }\\n }\\n\\n /**\\n * @dev Returns the address that signed a hashed message (`hash`) with\\n * `signature` or error string. This ", + "address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it.\\n *\\n * Documentation for signature generation:\\n * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\\n * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover(bytes32 hash, bytes memory signature" + ], + [ + ";\\n if (value == 0) break;\\n }\\n return buffer", + ";\\n }\\n }\\n\\n /**\\n * @dev " + ], + [ + "1;\\n string memory buffer = new string(length);\\n uint256 ptr;\\n /// @solidity memory-safe-assembly\\n assembly {\\n ", + "ptr := add(buffer, add(32, length))\\n }\\n while (true) {\\n ptr--;\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n }\\n value /= 10" + ], + [ + "RecoverError {\\n NoError,\\n InvalidSignature,\\n InvalidSignature", + "Length,\\n InvalidSignatureS,\\n InvalidSignatureV" + ], + [ + ");\\n }\\n\\n // If the signature is valid (and not malleable), return the signer address\\n address signer = ecrecover(hash, v, r, s);\\n if (signer == address(0)) {\\n return (address(0), RecoverError.InvalidSignature);\\n }\\n\\n return (", + "signer, RecoverError.NoError);\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n */\\n function recover" + ], + [ + ");\\n } else {\\n return (address(0), RecoverError.InvalidSignatureLength);\\n }\\n }\\n\\n /**\\n * @dev Returns the address that signed a hashed message (`hash`) with\\n * `signature`. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it.\\n */\\n function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, signature);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover", + "} that receives the `r` and `vs` short-signature fields separately.\\n *\\n * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover" + ], + [ + "\\n }\\n\\n function _throwError(RecoverError error) private pure {\\n if (error == RecoverError.NoError) {\\n return; // no error: do nothing", + "\\n } else if (error == RecoverError.InvalidSignature) {\\n revert(\\\"ECDSA: invalid signature\\\");\\n } else if (error == RecoverError.InvalidSignatureLength) {\\n revert(\\\"ECDSA: invalid signature length\\\");\\n } else if (error == RecoverError.InvalidSignatureS) {\\n revert(\\\"ECDSA: invalid signature 's' value" + ], + [ + "1;\\n string memory buffer = new string(length);\\n uint256 ptr;\\n /// @solidity memory-safe-assembly\\n assembly {\\n ptr := add(buffer, add(32, length))\\n }\\n while (true) {\\n ptr--;\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n }\\n value /= 10", + ";\\n if (value == 0) break;\\n }\\n return buffer;\\n }\\n }\\n\\n /**\\n * @dev " + ], + [ + " ", + "will " + ], + [ + "\"", + "x" + ], + [ + "(", + ");\\n }\\n}\\n\"" + ], + [ + ".", + "\\n /// @dev " + ], + [ + ";", + "\\n * " + ], + [ + "B", + "X96" + ], + [ + "B", + "unn" + ], + [ + "D", + "a" + ], + [ + "K", + " " + ], + [ + "L", + "ow" + ], + [ + "V", + "G" + ], + [ + "[", + "{\\\"" + ], + [ + "_", + "key" + ], + [ + "_", + "pausers" + ], + [ + "`", + "address(0)" + ], + [ + "c", + " " + ], + [ + "p", + "ancake" + ], + [ + "x", + ", " + ], + [ + "y", + "ield " + ], + [ + "{", + "\\r\\n function " + ], + [ + " ", + "| " + ], + [ + "\\n", + "\\n uint256 " + ], + [ + "\\n ", + "mapping (address => " + ], + [ + "int", + "egr" + ], + [ + ", ", + "32" + ], + [ + ");", + "\\n " + ], + [ + "is", + "Point" + ], + [ + "ERC", + "1820" + ], + [ + "d ", + "the " + ], + [ + "/**", + "\\n * @notice " + ], + [ + "us", + "to" + ], + [ + ": ", + "INVALID" + ], + [ + ") {", + " // " + ], + [ + "Re", + "ach" + ], + [ + "wa", + "s a " + ], + [ + "an ", + "initial " + ], + [ + "In", + "crease" + ], + [ + "set", + "MaxWallet" + ], + [ + "total", + "Balance" + ], + [ + "oli", + "dity " + ], + [ + "bytes32", + "(" + ], + [ + "require(", + "_exists(tokenId), \\\"ERC721: operator query for nonexistent token" + ], + [ + "****", + "**" + ], + [ + "token ", + "is not " + ], + [ + "The ", + "caller must own the token or be an approved operator.\\n */\\n error " + ], + [ + ";\\n\\n", + "/// @notice " + ], + [ + ");\\n\\n ", + "/**\\n@notice " + ], + [ + "length", + ".\\n " + ], + [ + "are ", + "a " + ], + [ + "this ", + "call" + ], + [ + " (", + "https://github.com/" + ], + [ + "12", + "6" + ], + [ + "// S", + "olidity " + ], + [ + "Swap", + "TokensAtAmount" + ], + [ + "pragma solidity ", + "=" + ], + [ + "\\\");\\n ", + "}\\n\\n " + ], + [ + "noti", + "fy" + ], + [ + ";\\n ", + "string public " + ], + [ + "uint8", + "8" + ], + [ + "[] ", + "storage " + ], + [ + "point", + "ers" + ], + [ + "payable", + "(msg.sender" + ], + [ + "liquidity", + "Wallet" + ], + [ + "\\r\\n ", + "uint256 " + ], + [ + "\\r\\n *", + "/" + ], + [ + "\\\");\\n\\n ", + "uint256 " + ], + [ + "::", + "mint" + ], + [ + "read", + "s from the " + ], + [ + "&&", + "\\r\\n " + ], + [ + "ref", + "resh" + ], + [ + "Mo", + "del" + ], + [ + "update", + "Project" + ], + [ + "E_", + "RATE_" + ], + [ + ".\\n ", + "event " + ], + [ + "slot", + "\\n " + ], + [ + "address owner", + ",\\r\\n address " + ], + [ + "required ", + "role" + ], + [ + "Lock", + "Until" + ], + [ + "Note that ", + "this " + ], + [ + ");\\r\\n }\\r\\n", + " " + ], + [ + "Strings", + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./math/Math" + ], + [ + "WAR", + "D" + ], + [ + ".\\n */\\n error ", + "Invalid" + ], + [ + "Di", + "rect" + ], + [ + "author", + "ize" + ], + [ + "collateral", + "_amount" + ], + [ + "quantity ", + "<= " + ], + [ + "TRA", + "CT" + ], + [ + ". This is ", + "a " + ], + [ + "uri", + "Prefix" + ], + [ + "{\\n /**\\n * @dev ", + "Emitted when the " + ], + [ + "directly ", + "to the " + ], + [ + "Trading", + "Open" + ], + [ + "multiple ", + "reads from the " + ], + [ + "mapping(address => bool", + ") " + ], + [ + "];\\n ", + "if (" + ], + [ + "PERMIT_TYPEHASH", + ", owner, " + ], + [ + "delete", + "DefaultRoyalty" + ], + [ + "some ", + "tokens " + ], + [ + "copy", + "right " + ], + [ + "\"log(", + "bool," + ], + [ + "right", + "most " + ], + [ + "devWallet", + "Updated" + ], + [ + "mu", + "ch" + ], + [ + "vali", + "dity" + ], + [ + "match", + "es the " + ], + [ + "burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer", + "(\\n address from,\\n address to,\\n uint256 tokenId\\n " + ], + [ + " to prevent ", + "multiple reads from the " + ], + [ + "reset", + "TokenRoyalty" + ], + [ + "trait", + "s." + ], + [ + "redemp", + "tion " + ], + [ + "_exists(tokenId), \\\"ERC721: ", + "approved query for nonexistent token" + ], + [ + "isExcludedFromFees", + "[to]" + ], + [ + "pause ", + "is " + ], + [ + "_approve(_msgSender(), spender, _allowances[_msgSender()][spender", + "].sub(subtractedValue, \\\"ERC20: decreased allowance below zero\\\")" + ], + [ + "fra", + "x" + ], + [ + ",\\n uint liquidity", + ",\\n uint amountAMin,\\n uint amountBMin,\\n address to,\\n uint deadline" + ], + [ + "whenNotPaused ", + "{\\n _" + ], + [ + ") return ", + "0" + ], + [ + "royaltyInfo", + "(uint256 tokenId, uint256 " + ], + [ + "──", + "──" + ], + [ + "uint256) {", + "\\r\\n " + ], + [ + "balanceOf(to", + ") <= " + ], + [ + "Percentage ", + "= " + ], + [ + "Nam", + "e = " + ], + [ + "] = false", + ";\\n emit " + ], + [ + "^^", + "^^" + ], + [ + ") internal view returns (uint256) {\\n return _length(set._inner", + ");\\n }\\n\\n" + ], + [ + " {\\n enum ", + "RecoverError {\\n NoError,\\n InvalidSignature,\\n InvalidSignatureLength,\\n InvalidSignatureS,\\n InvalidSignatureV" + ], + [ + "(\\n address tokenA,\\n address tokenB", + ",\\n uint liquidity,\\n uint amountAMin,\\n uint amountBMin,\\n address to,\\n uint deadline" + ], + [ + "allows children to implement ", + "an emergency " + ], + [ + "(sender, recipient, amount);\\n\\n uint256 ", + "currentAllowance = " + ], + [ + "manualBurn", + "Frequency" + ], + [ + "sch", + "em" + ], + [ + "elaps", + "ed" + ], + [ + ",\\n uint256[] memory balances,\\n uint256 ", + "lastChangeBlock" + ], + [ + ");\\r\\n }\\r\\n\\r\\n /**\\r\\n * @dev Returns the ", + "downcasted " + ], + [ + "OpenZeppelin Contracts v4.", + "4.1 (" + ], + [ + "Exec", + "ut" + ], + [ + "eip1967.proxy.", + "implementation" + ], + [ + "fungi", + "ble " + ], + [ + "repl", + "ay " + ], + [ + "address cannot be ", + "0\"" + ], + [ + "createPair(address tokenA, address tokenB", + ") external returns (address pair" + ], + [ + " /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function ", + "at(" + ], + [ + "paye", + "e " + ], + [ + "// We ", + "read and " + ], + [ + "(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n ", + "address owner = ERC721.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId" + ], + [ + "Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\\n *\\n * These functions can be used to verify that a message was signed by the holder\\n * of the private keys of a given address.\\n */\\nlibrary ECDSA", + " {\\n enum RecoverError {\\n NoError,\\n InvalidSignature,\\n InvalidSignatureLength,\\n InvalidSignatureS,\\n InvalidSignatureV" + ], + [ + "automatedMarketMakerPairs[to", + "] " + ], + [ + "string memory) {\\n require(_exists(tokenId), \\\"", + "ERC721Metadata: URI query for nonexistent token" + ], + [ + "\\n mapping(uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping(address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping(uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping(address => mapping(address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection", + ".\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\\n return\\n interfaceId == type(IERC721).interfaceId ||\\n interfaceId == type(IERC721Metadata).interfaceId ||\\n super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: " + ], + [ + "_packedAddressData[owner", + "] " + ], + [ + ".add(amount);\\n ", + "_balances[account] = _balances[account].add(amount);\\n emit Transfer" + ], + [ + "Wrappers over Solidity's arithmetic operations with added overflow\\n * checks.\\n *\\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\\n * in bugs, because programmers usually assume that an overflow raises an\\n * error, which is the standard behavior in high level programming languages.\\n * `SafeMath` restores this intuition by reverting the transaction when an\\n * operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it alway", + "s.\\n */\\nlibrary SafeMath {\\n /**\\n * @dev Returns the addition" + ], + [ + "] private ", + "__gap;\\n}\\n\"" + ], + [ + "same storage slot", + "\\n uint256 " + ], + [ + "abi.decode(returndata", + ", (" + ], + [ + "Extension of {ERC20} that allows token holders to destroy both their own\\n * tokens and those that they have an allowance for, in a way that can be\\n * recognized off-chain (via event analysis).\\n */\\nabstract contract ERC20Burnable is Context, ERC20 {\\n /**\\n * @dev ", + "Destroys `amount` tokens from the caller.\\n *\\n * See {ERC20-_burn}.\\n */\\n function burn(uint256 amount) public virtual {\\n _burn(_msgSender(), amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, deducting from the caller's\\n * allowance.\\n *\\n * See {ERC20-_burn} and {ERC20-allowance}.\\n *\\n * Requirements:\\n *\\n * - the caller must have allowance for ``accounts``'s tokens of at least\\n * `amount`.\\n */\\n function burnFrom(address account, uint256 amount) public virtual " + ], + [ + ". This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1", + ";\\n }\\n }\\n\\n function reset(Counter storage counter) internal {\\n counter._value = " + ], + [ + "Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented, decremented or reset", + ". This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n\\n function reset(Counter storage counter) internal {\\n counter._value = " + ], + [ + " to prevent multiple reads from the ", + "same storage slot\\n uint256 " + ], + [ + "royaltyInfo(uint256 tokenId, uint256 ", + "salePrice" + ], + [ + ") internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n", + " /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(" + ], + [ + "// We read and ", + "store the " + ], + [ + " ", + "on " + ], + [ + "(", + "success, " + ], + [ + "(", + "see " + ], + [ + "3", + "cc" + ], + [ + "6", + "77" + ], + [ + "7", + "3" + ], + [ + "B", + "ecause " + ], + [ + "E", + "ch" + ], + [ + "H", + "ed" + ], + [ + "T", + "ermin" + ], + [ + "]", + "=" + ], + [ + "_", + "nonce" + ], + [ + "_", + "rewards" + ], + [ + "a", + "way " + ], + [ + "a", + "_n" + ], + [ + "f", + "9" + ], + [ + "g", + "rows " + ], + [ + "h", + "iddenMetadataUri" + ], + [ + "t", + "reasury " + ], + [ + "▐", + "████▌" + ], + [ + "\\n ", + "uint256 public constant " + ], + [ + "s ", + "array " + ], + [ + ", ", + "timestamp" + ], + [ + "ent", + "er" + ], + [ + "\\\"", + "\\n " + ], + [ + "\\\"", + ");\\r\\n" + ], + [ + "pu", + "l" + ], + [ + "from", + "Delegate" + ], + [ + "Token", + "s that " + ], + [ + "Owner", + " " + ], + [ + "call", + "s " + ], + [ + "call", + "s." + ], + [ + "ERC20", + " `" + ], + [ + " = ", + "64" + ], + [ + "pri", + "z" + ], + [ + "ess", + "entially a " + ], + [ + "able", + "OperatorFilterer" + ], + [ + "get", + "Prior" + ], + [ + "add", + "ed, " + ], + [ + "zero ", + "case" + ], + [ + "recipient", + ", " + ], + [ + "sender", + " is only " + ], + [ + "Ex", + "clusion" + ], + [ + "max", + "Wall" + ], + [ + "(uint256 ", + "id_" + ], + [ + "token ", + "amount" + ], + [ + "s.", + "\\r\\n *\\r\\n * " + ], + [ + "balances", + ",\\n " + ], + [ + "symbol", + "() external view returns (string memory" + ], + [ + "ha", + "ving " + ], + [ + "this ", + "module" + ], + [ + "swap", + "Enabled = true" + ], + [ + "fo", + "re" + ], + [ + "Requirement", + "s" + ], + [ + "zero", + ".\\n * - `" + ], + [ + "Wallet", + "Limit" + ], + [ + "tokens", + "\"" + ], + [ + "string memory ", + "str" + ], + [ + "s, ", + "but " + ], + [ + "` is ", + "equal" + ], + [ + "balance ", + "= (" + ], + [ + "balance ", + "* _" + ], + [ + "block.", + "chain" + ], + [ + "is not ", + "in the " + ], + [ + "our", + "selves" + ], + [ + "__", + "/ " + ], + [ + ",\\n ", + "address(this),\\n " + ], + [ + "Updat", + "es the " + ], + [ + " ", + "The " + ], + [ + "grad", + "ient" + ], + [ + " {\\n ", + "event " + ], + [ + "use ", + "`" + ], + [ + ");\\r\\n ", + "return " + ], + [ + "E_", + "OFFSET" + ], + [ + "Pr", + "incipal" + ], + [ + "ing the ", + "contract " + ], + [ + ";\\n\\n ", + "uint256 " + ], + [ + "e.", + "\\n */\\nabstract contract " + ], + [ + "transfer to ", + "the zero address.\\n */\\n error " + ], + [ + ")\\n ", + "int256 constant x" + ], + [ + "We ", + "write the " + ], + [ + " bits", + "\\n */\\n function toUint" + ], + [ + "claim", + "Token" + ], + [ + "_address", + ", " + ], + [ + "while ", + "loop" + ], + [ + "also ", + "handles the " + ], + [ + "() public view virtual override returns (", + "string memory) {\\r\\n return " + ], + [ + "values", + "\\n " + ], + [ + "invalid ", + "token ID" + ], + [ + "Gu", + "ard" + ], + [ + "Claim", + " " + ], + [ + "initializ", + "es " + ], + [ + ");\\r\\n }\\r\\n", + "\\r\\n " + ], + [ + ".\\n */\\n error ", + "TransferFromIncorrectOwner" + ], + [ + ".\\n */\\n error ", + "MintZeroQuantity" + ], + [ + ") external;\\n\\n /**\\n * @dev ", + "Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved" + ], + [ + "28", + "f" + ], + [ + ".\\r\\n *\\r\\n * ", + "Counterpart to Solidity's `" + ], + [ + "share", + "holder" + ], + [ + "Exceed", + "ed" + ], + [ + "config", + "uration" + ], + [ + "max ", + "supply " + ], + [ + "mint to ", + "the zero address.\\n */\\n error " + ], + [ + "umul", + "ative " + ], + [ + "glob", + "ally " + ], + [ + ".sol\\\";\\nimport \\\"@openzeppelin/contracts/", + "access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/" + ], + [ + "permission", + " to " + ], + [ + "need to ", + "be " + ], + [ + ".\\n ", + "if (" + ], + [ + "some", + "times " + ], + [ + "\\n */\\n ", + "modifier only" + ], + [ + "Cach", + "e(" + ], + [ + "net", + "work " + ], + [ + ";\\r\\n }\\r\\n\\r\\n function ", + "set" + ], + [ + "most ", + "digit" + ], + [ + ";\\n _", + "expTable" + ], + [ + "Deposit", + "ed" + ], + [ + "();\\n\\n /**\\n * The ", + "caller must own the token or be an approved operator.\\n */\\n error " + ], + [ + "();\\n\\n /**\\n * The ", + "quantity of tokens minted must be more than zero" + ], + [ + "x ", + "-= x" + ], + [ + "Ent", + "ry" + ], + [ + "during ", + "construction" + ], + [ + ");\\n\\n ", + "emit " + ], + [ + "ensure", + "(" + ], + [ + "ensure", + "s that " + ], + [ + "ONE", + ") / _" + ], + [ + "Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with ", + "GSN " + ], + [ + "ERC721Receiver ", + "interface.\\n */\\n error " + ], + [ + "Note: ", + "the " + ], + [ + "push", + "(" + ], + [ + "Dec", + "l" + ], + [ + "Info ", + "memory " + ], + [ + "= (", + "votingPower" + ], + [ + ", address p3) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(", + "bool," + ], + [ + ", string memory p3) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(", + "bool," + ], + [ + ", bool p3) internal view {\\n\\t\\t_sendLogPayload(abi.encodeWithSignature(\\\"log(", + "bool," + ], + [ + "TransferToNonERC721ReceiverImplementer", + "();\\n\\n /**\\n * Cannot " + ], + [ + "light", + "weight " + ], + [ + "receiver, ", + "uint96 feeNumerator" + ], + [ + "those ", + "cases " + ], + [ + "(address sender, address recipient, uint256 amount", + ") public virtual override returns (bool) {\\n _transfer" + ], + [ + "USD", + "C" + ], + [ + "\\\";\\n ", + "string private " + ], + [ + "Rate ", + "= " + ], + [ + "burn(uint256 tokenId", + ") internal virtual {\\n _burn(tokenId, false);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId, bool approvalCheck" + ], + [ + "SH", + "IP" + ], + [ + ");\\n }\\n", + "}\\n\\n" + ], + [ + "TransferCallerNotOwnerNorApproved", + "();\\n\\n /**\\n * The token " + ], + [ + "Permit ", + "{\\n /**\\n * @dev Sets `value` as the allowance of `spender` " + ], + [ + "b7", + "9b" + ], + [ + "function that ", + "delegates " + ], + [ + "Pending", + "Admin" + ], + [ + "utils/cryptography/", + "MerkleProof" + ], + [ + "();\\n\\n /**\\n * Cannot ", + "query the balance for " + ], + [ + "();\\n\\n /**\\n * Cannot ", + "safely transfer to a contract that does not " + ], + [ + "();\\n\\n /**\\n * Cannot ", + "mint to the zero address.\\n */\\n error " + ], + [ + "processMultiProof", + "Calldata" + ], + [ + "Bo", + "x" + ], + [ + "Growth", + "Invariant" + ], + [ + "left", + "most digit" + ], + [ + "0, // ", + "slippage is unavoidable" + ], + [ + "Cor", + "respond" + ], + [ + "Given", + "In" + ], + [ + "OWNER", + "SHIP" + ], + [ + "free memory ", + "pointer to " + ], + [ + "the zero address.\\n */\\n error ", + "BalanceQueryForZeroAddress" + ], + [ + "OwnerQueryForNonexistentToken", + "();\\n\\n /**\\n * The caller must own the token or be an approved operator.\\n */\\n error " + ], + [ + "respon", + "se " + ], + [ + "String operations.\\n */\\nlibrary Strings {\\n bytes16 private constant _", + "SYMBOLS = \\\"0123456789abcdef\\\";\\n uint8 private constant _ADDRESS_LENGTH = 20;\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n uint256 " + ], + [ + "Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ", + "====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size" + ], + [ + "ApprovalCallerNotOwnerNorApproved", + "();\\n\\n /**\\n * The token does not exist.\\n */\\n error " + ], + [ + "TransferToZeroAddress", + "();\\n\\n /**\\n * The token does not exist.\\n */\\n error " + ], + [ + "accumul", + "ated " + ], + [ + " != 0) {\\n ", + "votingPower " + ], + [ + " != 0) {\\n ", + "balance = (" + ], + [ + "();\\n\\n /**\\n * The token does not exist.\\n */\\n error ", + "OwnerQueryForNonexistentToken();\\n\\n /**\\n * The caller must own the token or be an approved operator.\\n */\\n error " + ], + [ + " that ", + "also handles the " + ], + [ + "black", + "list " + ], + [ + "must be owned by `from`", + ".\\n */\\n error TransferFromIncorrectOwner" + ], + [ + ".\\n _", + "onlyOwnerOrSelf" + ], + [ + ") internal virtual override {\\n ", + "super._beforeTokenTransfer" + ], + [ + "lim", + "its " + ], + [ + "EEEEEEEE", + "EEEEEEEE" + ], + [ + "_allowances[sender][_msgSender()", + "];\\n require(" + ], + [ + "mstore(0x00", + ", 0x" + ], + [ + "41", + "EC" + ], + [ + "67", + "33" + ], + [ + "have the ", + "following " + ], + [ + "to.code.length", + " != 0" + ], + [ + "_pric", + "e(" + ], + [ + "a = ", + "(a * " + ], + [ + "emit OwnershipTransferred(_owner", + ", newOwner" + ], + [ + ")`.\\n */\\n function _", + "safeMint(address to, uint256 quantity" + ], + [ + ")`.\\n */\\n function _", + "burn(uint256 tokenId) internal virtual {\\n _burn(tokenId, false);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId, bool approvalCheck" + ], + [ + "\"Swap amount cannot be ", + "lower than 0.001% total supply.\"" + ], + [ + "`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes calldata data\\n ", + ") external;\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to" + ], + [ + "permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ", + ") external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature " + ], + [ + ";\\n seriesSum += ", + "term" + ], + [ + ";\\n seriesSum += ", + "num / " + ], + [ + "MintToZeroAddress", + "();\\n\\n /**\\n * The quantity of tokens minted must be more than zero" + ], + [ + "(\\n address token,\\n uint liquidity,\\n uint amountTokenMin,\\n uint amountETHMin,\\n address to,\\n uint deadline", + ",\\n bool approveMax, uint8 v, bytes32 r, bytes32 s" + ], + [ + "the owner or ", + "contract itself" + ], + [ + "enough", + " to " + ], + [ + "following is ", + "essentially a " + ], + [ + "inner", + " " + ], + [ + "callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, ", + "spender, newAllowance" + ], + [ + "trigg", + "er " + ], + [ + "string memory name, string memory ", + "symbol" + ], + [ + "require(b > 0, errorMessage", + ");\\n return " + ], + [ + "pool-utils/", + "contracts/" + ], + [ + ")\\n }\\n ", + "assembly {\\n " + ], + [ + "unclaimed", + "Pool" + ], + [ + "maxTotal", + "MintableBy" + ], + [ + "x >= ", + "x" + ], + [ + "r := shr(f, r", + ")\\n }\\n assembly {\\n " + ], + [ + "_balances[recipient] += amount", + ";\\n\\n emit Transfer" + ], + [ + "ERR", + "OR" + ], + [ + "uint256 currentAllowance = _allowances[_msgSender()][spender", + "];\\n require(" + ], + [ + " != 0) ratio = (ratio * ", + "0x" + ], + [ + "ByOwnerOrGovernance ", + "{\\n " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ", + ") internal virtual {\\n require(ERC721.ownerOf(tokenId) == from, \\\"ERC721: " + ], + [ + "_operatorApprovals[_msgSender()", + "][operator] = approved;\\n emit ApprovalForAll" + ], + [ + "signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function ", + "permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature " + ], + [ + "blockForPenalty", + "End" + ], + [ + "_balances[recipient] = _balances[recipient].add(amount);\\n emit Transfer", + "(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` " + ], + [ + ".\\n *\\n * startTokenId - the first token id to be transferred\\n * quantity - the amount to be transferred\\n *\\n * Calling conditions:\\n *\\n * - ", + "When `from` and `to` are both non-zero, `from`'s " + ], + [ + "term = ((term * x) / ONE_20", + ") / " + ], + [ + ") {\\n // On the first call to nonReentrant, _notEntered will be true\\n require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED;\\n\\n _;\\n\\n // ", + "By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200)\\n _status = _NOT_ENTERED;\\n }\\n}\\n\"" + ], + [ + "toHexString(value, Math.log256(value) + ", + "1);\\n }\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = _SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer" + ], + [ + "length = Math.log10(value) + ", + "1;\\n string memory buffer = new string(length);\\n uint256 ptr;\\n /// @solidity memory-safe-assembly\\n assembly {\\n ptr := add(buffer, add(32, length))\\n }\\n while (true) {\\n ptr--;\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n }\\n value /= 10;\\n if (value == 0) break;\\n }\\n return buffer;\\n }\\n }\\n\\n /**\\n * @dev " + ], + [ + "address payable) {\\n return ", + "msg.sender" + ], + [ + "IERC721.sol\\\";\\nimport \\\"./IERC721Receiver.sol\\\";\\nimport \\\"./extensions/IERC721Metadata.sol\\\";\\nimport \\\"../../utils/Address.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\nimport \\\"../../utils/Strings.sol\\\";\\nimport \\\"../../utils/introspection/ERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721 is Context, ERC165, IERC721, IERC721Metadata {\\n using Address for address;\\n using Strings for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address", + "\\n mapping(uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping(address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping(uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping(address => mapping(address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\\n return\\n interfaceId == type(IERC721).interfaceId ||\\n interfaceId == type(IERC721Metadata).interfaceId ||\\n super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: " + ], + [ + "litt", + "le " + ], + [ + "do-", + "while loop" + ], + [ + "Address, uint64 _", + "nonce" + ], + [ + "Equivalent to `_burn(tokenId, false", + ")`.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n _burn(tokenId, false);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId, bool approvalCheck" + ], + [ + "Equivalent to `_safeMint(to, quantity, ''", + ")`.\\n */\\n function _safeMint(address to, uint256 quantity" + ], + [ + "token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n */\\ninterface IERC20", + "Permit {\\n /**\\n * @dev Sets `value` as the allowance of `spender` " + ], + [ + "Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n return ", + "toHexString(value, Math.log256(value) + 1);\\n }\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = _SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer" + ], + [ + "The caller must own the token or be an approved operator.\\n */\\n error ", + "ApprovalCallerNotOwnerNorApproved();\\n\\n /**\\n * The token does not exist.\\n */\\n error " + ], + [ + "rightmost ", + "dig" + ], + [ + ",\\n uint256[] memory balances,\\n uint256 lastChangeBlock", + ",\\n uint256 protocolSwapFeePercentage" + ], + [ + "(address(0), to, tokenId);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId", + ");\\n\\n // Clear approvals\\n _approve(address(0), tokenId);\\n\\n _balances[owner] -= 1;\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId" + ], + [ + "Counters\\n * @author Matt Condon (@shrugs)\\n * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number\\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\\n *\\n * Include with `using Counters for Counters.Counter;`\\n */\\nlibrary Counters {\\n struct Counter {\\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\\n // this feature: see https://github.com/ethereum/solidity/issues/4637\\n uint256 _value; // default: 0\\n }\\n\\n function current(Counter storage counter) internal view returns (uint256) {\\n return counter._value;\\n }\\n\\n function increment(Counter storage counter) internal {\\n unchecked {\\n counter._value += 1;\\n }\\n }\\n\\n function decrement(Counter storage counter) internal {\\n uint256 value = counter._value;\\n require(value > 0, \\\"Counter: decrement overflow\\\");\\n unchecked {\\n counter._value = value - 1;\\n }\\n }\\n\\n function reset(Counter storage counter) internal {\\n counter._value = ", + "0;\\n }\\n}\\n\"" + ], + [ + "sender is only ", + "the owner or contract itself" + ], + [ + "maxWall", + "Percent" + ], + [ + "balance * _", + "ONE) / _" + ], + [ + "transfer to the zero address.\\n */\\n error ", + "TransferToZeroAddress();\\n\\n /**\\n * The token does not exist.\\n */\\n error " + ], + [ + "We write the ", + "string " + ], + [ + ".\\n */\\n error MintZeroQuantity", + "();\\n\\n /**\\n * The token does not exist.\\n */\\n error OwnerQueryForNonexistentToken();\\n\\n /**\\n * The caller must own the token or be an approved operator.\\n */\\n error " + ], + [ + "ERC721Receiver interface.\\n */\\n error ", + "TransferToNonERC721ReceiverImplementer();\\n\\n /**\\n * Cannot " + ], + [ + "= (votingPower", + " * _expTable" + ], + [ + "TransferCallerNotOwnerNorApproved();\\n\\n /**\\n * The token ", + "must be owned by `from`.\\n */\\n error TransferFromIncorrectOwner" + ], + [ + "();\\n\\n /**\\n * Cannot query the balance for ", + "the zero address.\\n */\\n error BalanceQueryForZeroAddress" + ], + [ + "();\\n\\n /**\\n * Cannot mint to the zero address.\\n */\\n error ", + "MintToZeroAddress();\\n\\n /**\\n * The quantity of tokens minted must be more than zero" + ], + [ + "String operations.\\n */\\nlibrary Strings {\\n bytes16 private constant _SYMBOLS = \\\"0123456789abcdef\\\";\\n uint8 private constant _ADDRESS_LENGTH = 20;\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n uint256 ", + "length = Math.log10(value) + 1;\\n string memory buffer = new string(length);\\n uint256 ptr;\\n /// @solidity memory-safe-assembly\\n assembly {\\n ptr := add(buffer, add(32, length))\\n }\\n while (true) {\\n ptr--;\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n }\\n value /= 10;\\n if (value == 0) break;\\n }\\n return buffer;\\n }\\n }\\n\\n /**\\n * @dev " + ], + [ + " != 0) {\\n votingPower ", + "= (votingPower * _expTable" + ], + [ + " != 0) {\\n balance = (", + "balance * _ONE) / _" + ], + [ + " that also handles the ", + "zero case" + ], + [ + "a = (a * ", + "ONE_20) / " + ], + [ + "following is essentially a ", + "do-while loop" + ], + [ + "The caller must own the token or be an approved operator.\\n */\\n error ApprovalCallerNotOwnerNorApproved();\\n\\n /**\\n * The token does not exist.\\n */\\n error ", + "ApprovalQueryForNonexistentToken" + ], + [ + "sender is only the owner or contract itself", + ".\\n _onlyOwnerOrSelf" + ], + [ + "transfer to the zero address.\\n */\\n error TransferToZeroAddress();\\n\\n /**\\n * The token does not exist.\\n */\\n error ", + "URIQueryForNonexistentToken" + ], + [ + ".\\n */\\n error MintZeroQuantity();\\n\\n /**\\n * The token does not exist.\\n */\\n error OwnerQueryForNonexistentToken();\\n\\n /**\\n * The caller must own the token or be an approved operator.\\n */\\n error ", + "TransferCallerNotOwnerNorApproved();\\n\\n /**\\n * The token must be owned by `from`.\\n */\\n error TransferFromIncorrectOwner" + ], + [ + "ERC721Receiver interface.\\n */\\n error TransferToNonERC721ReceiverImplementer();\\n\\n /**\\n * Cannot ", + "transfer to the zero address.\\n */\\n error TransferToZeroAddress();\\n\\n /**\\n * The token does not exist.\\n */\\n error URIQueryForNonexistentToken" + ], + [ + "();\\n\\n /**\\n * Cannot query the balance for the zero address.\\n */\\n error BalanceQueryForZeroAddress", + "();\\n\\n /**\\n * Cannot mint to the zero address.\\n */\\n error MintToZeroAddress();\\n\\n /**\\n * The quantity of tokens minted must be more than zero" + ], + [ + " != 0) {\\n balance = (balance * _ONE) / _", + "expTable" + ], + [ + "following is essentially a do-while loop", + " that also handles the zero case" + ], + [ + ".\\n */\\n error MintZeroQuantity();\\n\\n /**\\n * The token does not exist.\\n */\\n error OwnerQueryForNonexistentToken();\\n\\n /**\\n * The caller must own the token or be an approved operator.\\n */\\n error TransferCallerNotOwnerNorApproved();\\n\\n /**\\n * The token must be owned by `from`.\\n */\\n error TransferFromIncorrectOwner", + "();\\n\\n /**\\n * Cannot safely transfer to a contract that does not " + ], + [ + "();\\n\\n /**\\n * Cannot query the balance for the zero address.\\n */\\n error BalanceQueryForZeroAddress();\\n\\n /**\\n * Cannot mint to the zero address.\\n */\\n error MintToZeroAddress();\\n\\n /**\\n * The quantity of tokens minted must be more than zero", + ".\\n */\\n error MintZeroQuantity();\\n\\n /**\\n * The token does not exist.\\n */\\n error OwnerQueryForNonexistentToken();\\n\\n /**\\n * The caller must own the token or be an approved operator.\\n */\\n error TransferCallerNotOwnerNorApproved();\\n\\n /**\\n * The token must be owned by `from`.\\n */\\n error TransferFromIncorrectOwner();\\n\\n /**\\n * Cannot safely transfer to a contract that does not " + ], + [ + "(", + "newImplementation" + ], + [ + ")", + "[" + ], + [ + "-", + "value" + ], + [ + ".", + "\\n */\\n\\n" + ], + [ + "2", + "c8" + ], + [ + "4", + "00" + ], + [ + "7", + "9" + ], + [ + "8", + "1" + ], + [ + ";", + "\\n }\\n " + ], + [ + "=", + "\\n " + ], + [ + "O", + "(n" + ], + [ + "W", + "OOL" + ], + [ + "]", + ";\\n\\n " + ], + [ + "_", + "y" + ], + [ + "_", + "no" + ], + [ + "_", + "signature" + ], + [ + "_", + "presale" + ], + [ + "g", + "t" + ], + [ + "r", + "ice" + ], + [ + "s", + "ample " + ], + [ + "t", + "Marketing" + ], + [ + "\\n", + "pragma solidity 0.8.17" + ], + [ + "\\n ", + "error " + ], + [ + "\\n ", + ") private pure returns (" + ], + [ + "int", + "o" + ], + [ + "to", + "p" + ], + [ + ", ", + "deadline" + ], + [ + "//", + "\\n // " + ], + [ + "uint256", + "[]" + ], + [ + "or", + "ter" + ], + [ + ") ", + "== 0" + ], + [ + "token", + ".safeTransfer(" + ], + [ + "end", + ", " + ], + [ + "end", + ");\\n // Reentrancy protection" + ], + [ + "a ", + "to " + ], + [ + "public", + "Drop" + ], + [ + "Token", + "Address" + ], + [ + "Token", + "Contract" + ], + [ + "or ", + "not the " + ], + [ + ".\\n *\\n * ", + "To " + ], + [ + "internal ", + "immutable " + ], + [ + "} ", + "is " + ], + [ + "new", + "Beacon" + ], + [ + "), ", + "1" + ], + [ + "pro", + "ceed" + ], + [ + ", uint256 ", + "toTokenId" + ], + [ + "The ", + "easiest way to bubble the revert reason is using memory via assembly" + ], + [ + "ETH", + "Amount" + ], + [ + "ce", + "ed " + ], + [ + "totalSupply", + " * " + ], + [ + "log", + "ic " + ], + [ + "bytes32 ", + "value" + ], + [ + "bool ", + "isApprovedOrOwner" + ], + [ + "IP", + "rice" + ], + [ + "\\n // ", + "`" + ], + [ + "util", + "ity" + ], + [ + "\\n */\\n function ", + "mint" + ], + [ + "uint8", + "0 " + ], + [ + "of", + "\\n // the " + ], + [ + "Id ", + "= _" + ], + [ + "0, ", + "a " + ], + [ + ") internal virtual ", + "returns (" + ], + [ + "ort", + "ed " + ], + [ + "only ", + "if the " + ], + [ + "\\\\", + "/" + ], + [ + "support", + "ed, " + ], + [ + "read", + "ing and " + ], + [ + ".\\n ", + "for (uint256 i = 0; i < " + ], + [ + ".length", + ";\\n uint256 " + ], + [ + ", address indexed ", + "to" + ], + [ + ", address indexed ", + "from, address indexed " + ], + [ + "we ", + "don't " + ], + [ + "fees", + "wap" + ], + [ + ".\\n ", + "mapping(uint256 => " + ], + [ + "()", + "` " + ], + [ + ") {\\n require(", + "_exists(tokenId), \\\"ERC721: approved query for nonexistent token" + ], + [ + ")\\n ", + "revert " + ], + [ + ".sol\\\";\\n\\n/**\\n * @dev ", + "String operations.\\n */\\nlibrary Strings {\\n bytes16 private constant _SYMBOLS = \\\"0123456789abcdef\\\";\\n uint8 private constant _ADDRESS_LENGTH = 20;\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n uint256 length = Math.log10(value) + 1;\\n string memory buffer = new string(length);\\n uint256 ptr;\\n /// @solidity memory-safe-assembly\\n assembly {\\n ptr := add(buffer, add(32, length))\\n }\\n while (true) {\\n ptr--;\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n }\\n value /= 10;\\n if (value == 0) break;\\n }\\n return buffer;\\n }\\n }\\n\\n /**\\n * @dev " + ], + [ + "withdraw", + "al" + ], + [ + "claim", + "able" + ], + [ + "by", + "\\n // " + ], + [ + ";\\n emit ", + "Un" + ], + [ + "while ", + "still " + ], + [ + "subscri", + "be " + ], + [ + "key", + "-value " + ], + [ + "delegate ", + "call to non-contract\"" + ], + [ + "stake", + "Shares" + ], + [ + "\"Address: ", + "delegate call to non-contract\"" + ], + [ + "uint128", + " _" + ], + [ + "fund", + "ing " + ], + [ + "position", + "." + ], + [ + "at the ", + "given " + ], + [ + "By", + "Partition" + ], + [ + ".\\n", + "\\n " + ], + [ + "_operator", + "Data" + ], + [ + "Lib", + "Part" + ], + [ + "bas", + "isPoints" + ], + [ + ") internal virtual {", + "}\\r\\n" + ], + [ + "_initial", + "Supply" + ], + [ + "\\\");", + "\\r\\n " + ], + [ + "permission", + "s" + ], + [ + "224", + "f810" + ], + [ + "60", + "b79b" + ], + [ + "on be", + "half" + ], + [ + "3c", + "d4" + ], + [ + "dF", + "41EC" + ], + [ + "Af", + "a08" + ], + [ + "s. ", + "Some" + ], + [ + "Batch", + "Head" + ], + [ + "AA", + "eB6" + ], + [ + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./", + "IAccessControl" + ], + [ + "(\\r\\n address ", + "sender,\\r\\n address " + ], + [ + "bit", + "Length" + ], + [ + ")\\n ", + ")\\n )\\n " + ], + [ + "My", + "th" + ], + [ + "WITH", + "DRA" + ], + [ + "address(0x", + "0" + ], + [ + "Softwa", + "re" + ], + [ + "████████", + "████████" + ], + [ + "JoinExit", + "Supply" + ], + [ + "dd", + "A7" + ], + [ + "s[i", + "] " + ], + [ + "int128", + " " + ], + [ + "unchecked {\\n ", + "++i;\\n }\\n " + ], + [ + "trans", + "missions" + ], + [ + "ERC1967", + "Upgrade" + ], + [ + "-call", + "-value" + ], + [ + ") public virtual override {\\n require(", + "_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved" + ], + [ + "522", + "A7" + ], + [ + "3333333333333333", + "3333333333333333" + ], + [ + "ign", + "ed" + ], + [ + "sender ", + "must be an " + ], + [ + "resultPtr", + " := add(" + ], + [ + "votingPower", + "History" + ], + [ + ", pre", + "vious" + ], + [ + "you", + " to " + ], + [ + "end of the ", + "memory " + ], + [ + "El", + "aps" + ], + [ + "autoBurn", + "LiquidityPairTokens" + ], + [ + "allowed SeaDrop", + " " + ], + [ + "6C", + "ddA7" + ], + [ + ") internal pure returns (bytes32) {\\n return ", + "keccak256(abi.encodePacked(\\\"\\\\x19\\\\x01\\\", domainSeparator, structHash" + ], + [ + "observation", + "Cardinality" + ], + [ + "ERC721Enumerable: ", + "owner " + ], + [ + "unit ", + "of " + ], + [ + "FA", + "224f810" + ], + [ + "\"Buy ", + "transfer amount exceeds the maxTransactionAmount.\"" + ], + [ + "Optim", + "ized " + ], + [ + "calculate the ", + "length " + ], + [ + "OperatorNot", + "Allowed" + ], + [ + "Fr", + "agment" + ], + [ + "Deprec", + "ated" + ], + [ + "bytes32 internal ", + "constant _" + ], + [ + "000000000000", + "AAeB6" + ], + [ + "Funding", + "Cycle" + ], + [ + "180", + "6733" + ], + [ + "dC", + "eB6" + ], + [ + "\\\");\\n _safeTransfer", + "(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer" + ], + [ + "address(uint160", + "(_packedOwnershipOf(tokenId" + ], + [ + ") internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received", + "(from, to, tokenId, _data" + ], + [ + "(\\n bytes32 poolId,\\n address sender,\\n address recipient", + ",\\n uint256[] memory balances,\\n uint256 lastChangeBlock,\\n uint256 protocolSwapFeePercentage" + ], + [ + "'0", + "' " + ], + [ + ", pl", + "us " + ], + [ + ", but we ", + "add " + ], + [ + "assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting\\n * and burning.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, ``from``'s `tokenId` will be ", + "burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(\\n address from,\\n address to,\\n uint256 tokenId\\n " + ], + [ + "));\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Typed Data, created from a\\n * `domainSeparator` and a `structHash`. This produces hash corresponding\\n * to the one signed with the\\n * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\\n * JSON-RPC method as part of EIP-712.\\n *\\n * See {recover}.\\n */\\n function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash", + ") internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(\\\"\\\\x19\\\\x01\\\", domainSeparator, structHash" + ], + [ + "D76", + "70E" + ], + [ + "string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5", + ",0" + ], + [ + "{\\n // Ensure the ", + "sender is only the owner or contract itself.\\n _onlyOwnerOrSelf" + ], + [ + "Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount", + ") internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer" + ], + [ + "string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token", + "\\\");\\n\\n " + ], + [ + "3cc", + "6CddA7" + ], + [ + ") external;\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved", + ") external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev " + ], + [ + ") {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token", + "\\\");\\n\\n " + ], + [ + "60b79b", + "Afa08" + ], + [ + "3cd4", + "E" + ], + [ + "dF41EC", + "FA224f810" + ], + [ + "522A7", + "1806733" + ], + [ + "000000000000AAeB6", + "D7670E" + ], + [ + "3cc6CddA7", + "60b79bAfa08" + ], + [ + "dF41ECFA224f810", + "dCeB6" + ], + [ + "522A71806733", + "3cd4E" + ], + [ + "000000000000AAeB6D7670E", + "522A718067333cd4E" + ], + [ + "3cc6CddA760b79bAfa08", + "dF41ECFA224f810dCeB6" + ], + [ + "(", + "id" + ], + [ + "(", + "quantity == 1" + ], + [ + "+", + "1 " + ], + [ + "+", + "°." + ], + [ + "+", + ".*•´.*:" + ], + [ + ".", + "is" + ], + [ + "2", + "0000" + ], + [ + "9", + ".2" + ], + [ + ":", + "*.´" + ], + [ + "D", + "if" + ], + [ + "I", + "Uni" + ], + [ + "J", + "O" + ], + [ + "L", + "ast " + ], + [ + "O", + "G" + ], + [ + "P", + "l" + ], + [ + "W", + "ord " + ], + [ + "_", + "(" + ], + [ + "_", + "decimal" + ], + [ + "_", + "sellDevFee" + ], + [ + "_", + "merkleProof" + ], + [ + "_", + "entries" + ], + [ + "`", + "_projectId" + ], + [ + "d", + "0" + ], + [ + "e", + "p " + ], + [ + "g", + "ame" + ], + [ + "h", + "drn" + ], + [ + "i", + "b" + ], + [ + "p", + "f" + ], + [ + "s", + "mart contract" + ], + [ + "s", + "qr" + ], + [ + "˚", + ".°" + ], + [ + "˚", + "•´" + ], + [ + "˚", + ":*.´" + ], + [ + "•", + "*." + ], + [ + "on", + "es " + ], + [ + "\\n ", + "address " + ], + [ + "ti", + "call" + ], + [ + "ti", + "tion " + ], + [ + "in", + "struction" + ], + [ + "\\n *", + " " + ], + [ + ", ", + "address(this" + ], + [ + "ro", + "om" + ], + [ + "ow", + "ed and " + ], + [ + "token", + "Holder" + ], + [ + "end", + "ar" + ], + [ + "end", + " - " + ], + [ + "is", + "e" + ], + [ + "is", + "Pair" + ], + [ + "qu", + "ote(" + ], + [ + "To", + "Withdraw" + ], + [ + "` ", + "until " + ], + [ + "uint256 ", + "end" + ], + [ + "str", + "action" + ], + [ + "view", + "\\r\\n returns (" + ], + [ + "sp", + "ent" + ], + [ + "return ", + "ownership" + ], + [ + " = ", + "160" + ], + [ + "spender", + "Allowance" + ], + [ + "contract", + ".\\n *\\n * " + ], + [ + ") {\\n ", + "assembly {\\n " + ], + [ + "for ", + "multiple " + ], + [ + ";\\n ", + "} else if (" + ], + [ + "bytes32", + "[] " + ], + [ + "Return", + "s to normal " + ], + [ + "value ", + "of `" + ], + [ + "zero ", + "address\"" + ], + [ + "sub", + "straction" + ], + [ + "Of", + "Tokens" + ], + [ + "(uint256 ", + "shares" + ], + [ + "token ", + "The token " + ], + [ + "swap", + "Enabled " + ], + [ + "when ", + "setting " + ], + [ + "id", + "_ " + ], + [ + ") {\\n ", + "_" + ], + [ + ",\\n uint256 ", + "_amount" + ], + [ + "constant", + "s " + ], + [ + "// S", + "tor" + ], + [ + "_transfer", + "(_msgSender(), recipient, amount" + ], + [ + "ed by ", + "the call" + ], + [ + "Per", + "Address" + ], + [ + "Per", + "Wallet" + ], + [ + "\\n\\t", + "* " + ], + [ + "bytes memory ", + "return" + ], + [ + "can be ", + "prov" + ], + [ + "start", + "` " + ], + [ + "AT", + "E" + ], + [ + "OR", + "AC" + ], + [ + "fee", + "Protocol" + ], + [ + "`tokenId` ", + "from `from` to `to" + ], + [ + "\\r\\n *", + " " + ], + [ + "Pool", + "Id" + ], + [ + "Pool", + "Payout" + ], + [ + "from, ", + "to, value" + ], + [ + ")\\n ", + "returns (bool)\\n {\\n return " + ], + [ + "_isExcludedFrom", + "Max" + ], + [ + "Con", + "firmation" + ], + [ + "marketing", + "Amt" + ], + [ + "ari", + "ly " + ], + [ + "signed ", + "64.64" + ], + [ + ",\\r\\n ", + "uint amountToken" + ], + [ + "one ", + "of " + ], + [ + "try", + "ing to " + ], + [ + ");\\n _", + "require(" + ], + [ + "paused", + "\"" + ], + [ + "Add", + "ed(" + ], + [ + "withdraw", + "al " + ], + [ + "tokenId ", + "would have to be 2**256" + ], + [ + "Royalty", + "Percentage" + ], + [ + ");\\n return true", + ";\\n }\\n\\n /**\\n * @notice " + ], + [ + ".sol\\\";\\nimport \\\"./", + "interfaces/" + ], + [ + "Ar", + "bitrary " + ], + [ + "As", + "sign" + ], + [ + " / ", + "2" + ], + [ + "Paused", + "(address account" + ], + [ + "uni", + "verse" + ], + [ + "quantity ", + "- 1" + ], + [ + "Exceed", + "ed(" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n", + "pragma solidity 0.8.17" + ], + [ + "addLiquidityETH", + "{value: " + ], + [ + "role ", + "to " + ], + [ + "request", + "ed" + ], + [ + "rewards", + "Duration" + ], + [ + "manag", + "ed" + ], + [ + "Merkle", + "Proof " + ], + [ + "fixed ", + "point" + ], + [ + "_msgSenderERC721A", + "() != " + ], + [ + "that can be ", + "minted " + ], + [ + "enumer", + "able " + ], + [ + "require(b", + " <= a, errorMessage" + ], + [ + "member", + "s " + ], + [ + ")\\n // ", + "Move the pointer " + ], + [ + "IERC721A", + ".sol\"" + ], + [ + "que", + "ue " + ], + [ + "que", + "ued" + ], + [ + "ed to be ", + "a part of a " + ], + [ + "minting", + "Allowed" + ], + [ + ";\\n }\\n }\\n\\n /**\\n * @dev ", + "Returns the " + ], + [ + "{\\n _", + "paused = false" + ], + [ + "Update the ", + "free memory pointer to " + ], + [ + ")\\r\\n ", + "public\\r\\n " + ], + [ + "for {", + "\\n " + ], + [ + "int24", + "8" + ], + [ + "_packedOwnerships[", + "index] = " + ], + [ + "0.5.0", + ";\\n\\ninterface " + ], + [ + "MU", + "LT" + ], + [ + ", _msgSender()", + "), \\\"" + ], + [ + "Det", + "ermin" + ], + [ + "-in", + "-" + ], + [ + "AccessControl: ", + "sender must be an " + ], + [ + " * (", + "10 ** " + ], + [ + "address is ", + "zero" + ], + [ + ".selector, ", + "to, value" + ], + [ + "uint256)", + "')) == " + ], + [ + "trigge", + "red by " + ], + [ + ";\\n }\\n\\n ", + "/**\\n * @notice " + ], + [ + ".*", + "°." + ], + [ + "}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function ", + "transferFrom" + ], + [ + "\\n ///", + " " + ], + [ + "lastIndex", + " = " + ], + [ + "*.", + "˚•´" + ], + [ + "project ", + "`_projectId" + ], + [ + "contract is paused", + ", and " + ], + [ + "Meta", + "Transaction" + ], + [ + "lif", + "ted by " + ], + [ + ".°", + ":°•.°" + ], + [ + "°.", + "´" + ], + [ + "burned = ", + "true" + ], + [ + "pause ", + "is trigge" + ], + [ + "2,\\n 2,\\n 2,\\n 2,\\n ", + "2,\\n 2,\\n 2,\\n 2,\\n " + ], + [ + ".\\n uint256 private ", + "constant " + ], + [ + "Fac", + "e" + ], + [ + "'s index", + " to prevent multiple reads from the same storage slot\\n uint256 " + ], + [ + "Unpaused", + "(address account" + ], + [ + "\\\"}", + "],\\\"" + ], + [ + "The address ", + "which " + ], + [ + "prettier-ignore", + "\\n " + ], + [ + ";\\n }\\n _afterTokenTransfers(address(0), to, startTokenId, quantity", + ");\\n }\\n\\n /**\\n * @dev Mint" + ], + [ + "_treasury", + "Fee" + ], + [ + "(sender, recipient, amount);\\n\\n uint256 ", + "senderBalance = _balances[sender];\\n require(" + ], + [ + ") / _ONE", + ";\\n }\\n if (t & 0x" + ], + [ + "paused.\\n */\\n modifier ", + "whenNotPaused(" + ], + [ + "repe", + "tition " + ], + [ + "\"Sell ", + "transfer amount exceeds the maxTransactionAmount.\"" + ], + [ + "CL", + "UD" + ], + [ + "invocation", + "s" + ], + [ + "approve caller is not owner nor approved for all", + "\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address" + ], + [ + "Delegat", + "ee" + ], + [ + "meant to be ", + "called " + ], + [ + "Tra", + "its" + ], + [ + "in un", + "paused state" + ], + [ + "•°:", + "°.´" + ], + [ + "s\\\":", + "[{\\\"" + ], + [ + "p0) internal view {\\n\\t\\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature(\\\"log(", + "bytes" + ], + [ + "Provid", + "er " + ], + [ + "covered ", + "work" + ], + [ + ".\\r\\n *\\r\\n * Emits a {Transfer} event", + ".\\r\\n */\\r\\n function " + ], + [ + "Penal", + "ties" + ], + [ + ";\\n uint256 private immutable _", + "expTable" + ], + [ + "paused = true", + ";\\n emit " + ], + [ + "External interface of AccessControl", + " " + ], + [ + ".call{ value: ", + "amount " + ], + [ + "Compos", + "able" + ], + [ + "sentinel", + " " + ], + [ + "malici", + "ous " + ], + [ + ");\\n return a % b", + ";\\n }\\n}\\n\"" + ], + [ + "All three ", + "of these values are immutable: they can only be set once during\\n * construction" + ], + [ + "Implied", + "Rate" + ], + [ + "(address(this).", + "balance" + ], + [ + "Triggers ", + "stopped " + ], + [ + "bytes4 retval) {\\n return retval == IERC721Receiver.onERC721Received.selector", + ";\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n " + ], + [ + "IUniswapV2Router01 ", + "{\\n function " + ], + [ + ") return (false, 0);\\n return (true, c", + ");\\n }\\n }\\n\\n /**\\n * @dev Returns the " + ], + [ + "require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token", + "\\\");\\n " + ], + [ + "pause is ", + "lifted by " + ], + [ + "(sender, recipient, amount);\\n\\n uint256 currentAllowance = ", + "_allowances[sender][_msgSender()];\\n require(" + ], + [ + "bool isApprovedOrOwner", + " = (" + ], + [ + "funding ", + "cy" + ], + [ + "s. Some", + "\\n * " + ], + [ + ") public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: transfer caller is not owner nor approved", + "\\\");\\n _safeTransfer(from, to, tokenId, _data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `_data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer" + ], + [ + "));\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Typed Data, created from a\\n * `domainSeparator` and a `structHash`. This produces hash corresponding\\n * to the one signed with the\\n * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\\n * JSON-RPC method as part of EIP-712.\\n *\\n * See {recover}.\\n */\\n function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(\\\"\\\\x19\\\\x01\\\", domainSeparator, structHash", + "));\\n }\\n}\\n\"" + ], + [ + "˚.°", + "*.˚•´" + ], + [ + "can be prov", + "ed to be a part of a " + ], + [ + "ORAC", + "LE" + ], + [ + "_msgSenderERC721A() != ", + "owner" + ], + [ + "AccessControl: sender must be an ", + "admin to " + ], + [ + ".*°.", + "˚:*.´" + ], + [ + "pause is trigge", + "red by " + ], + [ + "approve caller is not owner nor approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address", + ") {\\n require(_exists(tokenId), \\\"ERC721: approved query for nonexistent token\\\");\\n\\n " + ], + [ + "˚.°*.˚•´", + ".°:°•.°" + ], + [ + "can be proved to be a part of a ", + "Merkle " + ], + [ + ")", + "\\r\\n " + ], + [ + ")", + "\\r\\n " + ], + [ + ",", + "\\r\\n\\t\\t" + ], + [ + ".", + "totalSupply" + ], + [ + ".", + "\\n *\\n * " + ], + [ + "4", + "3" + ], + [ + ">", + "'" + ], + [ + "F", + "ull" + ], + [ + "G", + "rou" + ], + [ + "N", + "ative" + ], + [ + "V", + "ari" + ], + [ + "[", + "_address" + ], + [ + "]", + " " + ], + [ + "_", + "0" + ], + [ + "_", + ", address " + ], + [ + "_", + "block" + ], + [ + "_", + "delegates" + ], + [ + "_", + "released" + ], + [ + "`", + "{IERC20-approve}" + ], + [ + "a", + "952" + ], + [ + "f", + "0" + ], + [ + "p", + "ol" + ], + [ + "\\n", + "/// @dev " + ], + [ + "\\n ", + "mapping(address => " + ], + [ + "s ", + "need to " + ], + [ + "\\n ", + "}\\n\\n return result" + ], + [ + "ad", + "1be" + ], + [ + "an", + "de" + ], + [ + "de", + "al " + ], + [ + "the ", + "functions " + ], + [ + "end", + "ed to be " + ], + [ + "is", + "Burn" + ], + [ + "to ", + "transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer" + ], + [ + "to ", + "keep the " + ], + [ + "to ", + "calculate the length " + ], + [ + "address ", + "for " + ], + [ + "// ", + "At " + ], + [ + "// ", + "Add the " + ], + [ + "uint256 ", + "contains " + ], + [ + "owner", + ",\\n uint256 " + ], + [ + "of ", + "your contract" + ], + [ + "return ", + "packed" + ], + [ + " = ", + "10" + ], + [ + "contract", + "Tokens" + ], + [ + "In", + "u" + ], + [ + "s/", + "contracts/" + ], + [ + "mo", + "de " + ], + [ + "Co", + "dec" + ], + [ + "ei", + "ght" + ], + [ + "from ", + "on-chain " + ], + [ + "by ", + "access" + ], + [ + "as ", + "possible" + ], + [ + ") public ", + "onlyOwner " + ], + [ + "sub", + "(_" + ], + [ + "16", + "3c" + ], + [ + "check", + "ed for " + ], + [ + "----", + "---" + ], + [ + "name", + ";\\n " + ], + [ + "are ", + "supported" + ], + [ + ";\\n\\n ", + "/**" + ], + [ + "pa", + "user " + ], + [ + "zero", + ".\\n " + ], + [ + "balanceOf", + "[" + ], + [ + "role", + "\"" + ], + [ + "/contracts/", + "\"" + ], + [ + "event ", + "log" + ], + [ + "Data", + "[" + ], + [ + "********", + "**" + ], + [ + ";\\n ", + "mapping(address => bool) public " + ], + [ + "See {", + "processMultiProof" + ], + [ + "s, ", + "which " + ], + [ + "_is", + "Blacklisted" + ], + [ + "_is", + "Black" + ], + [ + "constructor", + "(\\n address " + ], + [ + "lock", + "up" + ], + [ + "set ", + "on " + ], + [ + "remo", + "te" + ], + [ + "rol", + "es[role].members[account" + ], + [ + ") public view virtual ", + "returns (bool) {\\n return _" + ], + [ + "in the ", + "`" + ], + [ + "= _", + "values(set._inner" + ], + [ + "int256", + "(" + ], + [ + "ice", + "-" + ], + [ + ", amount", + "B" + ], + [ + ", amount", + ", \\\"" + ], + [ + "user", + "-f" + ], + [ + ", and ", + "its " + ], + [ + "_balances[", + "address(this)" + ], + [ + "(from, ", + "to" + ], + [ + "Operator", + " " + ], + [ + ");\\n }\\n\\n function ", + "_burn" + ], + [ + "Enabled", + "(" + ], + [ + "Log", + "ic" + ], + [ + "ERC721A", + "/" + ], + [ + "ating ", + "role" + ], + [ + "s are ", + "put in plac" + ], + [ + "we ", + "allocate " + ], + [ + "ren", + "cy " + ], + [ + "Initializ", + "able " + ], + [ + "55", + "a4" + ], + [ + "modifier", + "s `" + ], + [ + "modifier", + "s are put in plac" + ], + [ + "(1", + "e6" + ], + [ + ")\\n ", + "let " + ], + [ + ";\\r\\n ", + "if (" + ], + [ + "withdraw", + "Stuck" + ], + [ + "they ", + "will not be " + ], + [ + "claim", + "s" + ], + [ + "already ", + "been " + ], + [ + "message ", + "digest " + ], + [ + "utils/Context", + ".sol\\\";\\nimport \\\"../" + ], + [ + "AU", + "THOR" + ], + [ + "with the ", + "last " + ], + [ + ",\\n ", + "\\\"" + ], + [ + "to the ", + "pointer" + ], + [ + "ownership ", + "slot " + ], + [ + "larg", + "er " + ], + [ + ", 0x", + "04" + ], + [ + "uint256[] memory ", + "tokenId" + ], + [ + "application", + "s may " + ], + [ + "cr", + "ab" + ], + [ + "protocol", + "Fee" + ], + [ + "` and `", + "whenPaused" + ], + [ + "make ", + "room" + ], + [ + "high", + " = " + ], + [ + "digits", + ". " + ], + [ + ");\\n }\\n\\n /**\\n * @dev See {", + "IERC721Enumerable-" + ], + [ + "per ", + "digit" + ], + [ + "_initial", + "ize" + ], + [ + "start ", + "< stop" + ], + [ + ".sol\\\";\\nimport \\\"@openzeppelin/contracts/", + "utils/" + ], + [ + "Mask", + " " + ], + [ + "if it ", + "does" + ], + [ + ".\\n */\\nabstract contract ", + "ERC721" + ], + [ + ", b", + "pt" + ], + [ + "Dividend", + "Of" + ], + [ + "BaseURI", + "(string memory " + ], + [ + "that can be ", + "triggered by " + ], + [ + "mechanism ", + "that can be triggered by " + ], + [ + "Stake", + "Length" + ], + [ + "enumer", + "ability" + ], + [ + "enumer", + "ating role" + ], + [ + "Interface", + "LP" + ], + [ + "(sender, recipient, amount", + ");\\n\\n " + ], + [ + "s. ", + "See {processMultiProof" + ], + [ + "extcode", + "hash" + ], + [ + "address[] calldata path", + ",\\r\\n address to,\\r\\n uint deadline" + ], + [ + "CE", + "ED" + ], + [ + "store", + "\\n }\\n\\n return result" + ], + [ + ";\\n if (", + "absTick & 0x" + ], + [ + "da", + "a952" + ], + [ + "_approve(owner, spender, ", + "value" + ], + [ + "\\n // ", + "If the " + ], + [ + " ", + "The " + ], + [ + "`, which ", + "can be appli" + ], + [ + "E ", + "=\\n " + ], + [ + "revok", + "ed" + ], + [ + "Uri", + "Resolver" + ], + [ + ");\\n\\n if (", + "approvalCheck" + ], + [ + "whenNotPaused", + "` and `whenPaused" + ], + [ + "batch", + "Swap" + ], + [ + "bytes32[] memory ", + "store " + ], + [ + "state ", + "variable" + ], + [ + "avoid", + "-call-value" + ], + [ + "allow ", + "enumerating role" + ], + [ + "df", + "523" + ], + [ + "df", + "252" + ], + [ + "Contract module which ", + "allows children to implement an emergency " + ], + [ + "Bpt", + "Out" + ], + [ + ");\\n\\n /**\\n * @dev Emitted when the ", + "pause is lifted by " + ], + [ + " |", + " (" + ], + [ + "_packedOwnerships[", + "index" + ], + [ + "b3", + "ef" + ], + [ + ",\\n ", + "\\\"" + ], + [ + "IERC20 ", + "{\\n function " + ], + [ + ";\\n\\nimport \\\"@openzeppelin/contracts/", + "access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/" + ], + [ + "ba", + "7f" + ], + [ + "_development", + "Fee" + ], + [ + "result := ", + "store\\n }\\n\\n return result" + ], + [ + "wrapp", + "ed " + ], + [ + "draft-", + "EIP712" + ], + [ + "9b", + "69" + ], + [ + "details", + ".\\n *\\n * _Available since v4.7._\\n */\\n function " + ], + [ + "Modifier ", + "that " + ], + [ + "18 ", + "decimal" + ], + [ + "from != ", + "msg.sender" + ], + [ + "uint256 result", + ") {\\n // " + ], + [ + "benefit ", + "from on-chain " + ], + [ + "PPPP", + "PPPP" + ], + [ + "imilar", + " to " + ], + [ + "The maximum ", + "value of a " + ], + [ + "fc", + "378" + ], + [ + "off-chain ", + "means " + ], + [ + "_implementation", + "()" + ], + [ + "Word", + "Codec" + ], + [ + "Upgradeability", + "Proxy " + ], + [ + ". Note that ", + "they will not be " + ], + [ + "yield", + "-protocol/" + ], + [ + "''''", + "''''" + ], + [ + "(bytes memory ", + "s" + ], + [ + "modifi", + "es the " + ], + [ + "Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator", + ") external view returns (bool);\\n}\\n\"" + ], + [ + "4a", + "116" + ], + [ + "32 bytes ", + "leftwards to " + ], + [ + "nonces[owner", + "]." + ], + [ + "c2", + "b068" + ], + [ + "Mis", + "match" + ], + [ + "(\\n address sender,\\n address recipient,\\n uint256 amount\\n ", + ") public virtual override returns (bool) {\\n _transfer" + ], + [ + "computed ", + "hash" + ], + [ + "(pair", + ", value" + ], + [ + "keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n", + "\\\", " + ], + [ + "78 ", + "digits (" + ], + [ + "78 ", + "digits. " + ], + [ + "simply ", + "including " + ], + [ + "character ", + "to the pointer" + ], + [ + "pause() internal virtual ", + "whenPaused " + ], + [ + "hasRole(role, account)) {\\n _roles[role].members[account", + "] = true;\\n emit " + ], + [ + "hasRole(role, account)) {\\n _roles[role].members[account", + "] = false;\\n emit " + ], + [ + "type `", + "id" + ], + [ + "} for ", + "details.\\n *\\n * _Available since v4.7._\\n */\\n function " + ], + [ + "Cache the ", + "end of the memory " + ], + [ + "except through ", + "off-chain means " + ], + [ + "denomin", + "ated in " + ], + [ + "(address sender, address recipient, uint256 amount) external returns (bool", + ");\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\"" + ], + [ + "Keep ", + "dividing " + ], + [ + "Expir", + "y" + ], + [ + "the address ", + "returned by `" + ], + [ + "_call", + "Tokens" + ], + [ + "fromTokenId", + ", uint256 toTokenId" + ], + [ + "0xd", + "df252" + ], + [ + "MerkleProof.", + "verify" + ], + [ + "0xc", + "5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Returns true if the ", + "contract is paused, and " + ], + [ + "onlyAllowedOperator(from) {\\n ", + "super.safeTransferFrom" + ], + [ + "scaling ", + "factor" + ], + [ + "(uint256 x, uint256 ", + "y" + ], + [ + ";\\n\\n/*\\n * @dev ", + "Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with GSN " + ], + [ + ".send", + "Value" + ], + [ + "IVIS", + "OR" + ], + [ + ", only ", + "once the " + ], + [ + "therefo", + "re " + ], + [ + ".addr = ", + "from" + ], + [ + "CAUTION: Not all merkle trees admit multiproof", + "s. See {processMultiProof" + ], + [ + "Cool", + "down" + ], + [ + ", for ", + "those cases " + ], + [ + "\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^", + "0.6.0" + ], + [ + "),\\n \\\"ERC721: transfer to non ERC721Receiver implementer\\\"\\n );\\n }\\n\\n /**\\n * @dev Mint", + "s `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId);\\n\\n _balances[to] += 1;\\n _owners[tokenId] = to;\\n\\n emit Transfer" + ], + [ + "_balances[sender] = _balances[sender].sub(amount, \\\"ERC20: transfer ", + "amount exceeds balance\\\");\\n " + ], + [ + "_totalSupply = _totalSupply.sub(", + "amount);\\n emit Transfer" + ], + [ + "similar", + " to the " + ], + [ + "1 byte ", + "per digit" + ], + [ + "Write the ", + "character to the pointer" + ], + [ + "an authorized ", + "account" + ], + [ + ".\\n // The ", + "following is essentially a do-while loop that also handles the zero case" + ], + [ + "false otherwise.\\n */\\n function ", + "paused(" + ], + [ + "later.\\n let ", + "end := " + ], + [ + "usto", + "di" + ], + [ + ". This is a ", + "lightweight " + ], + [ + "whenNotPaused {\\n _", + "paused = true;\\n emit " + ], + [ + "this module", + ", only once the " + ], + [ + "block.chain", + "id == " + ], + [ + "ing the contract ", + "event log" + ], + [ + "28f", + "55a4" + ], + [ + "leftmost digit", + ".\\n // The following is essentially a do-while loop that also handles the zero case" + ], + [ + "2c8", + "9b69" + ], + [ + ";\\n emit Un", + "paused(" + ], + [ + "owed and ", + "to whom" + ], + [ + "Paused(address account", + ");\\n\\n /**\\n * @dev Emitted when the pause is lifted by " + ], + [ + "members ", + "except through off-chain means " + ], + [ + "{\\n _paused = false", + ";\\n emit Unpaused(" + ], + [ + "`{IERC20-approve}", + "`, the " + ], + [ + "ad1be", + "2c89b69" + ], + [ + "the functions ", + "of your contract" + ], + [ + "to keep the ", + "free memory pointer " + ], + [ + "uint256 contains ", + "78 digits (" + ], + [ + "by access", + "ing the contract event log" + ], + [ + "163c", + "4a116" + ], + [ + "= _values(set._inner", + ");\\n " + ], + [ + "modifiers `", + "whenNotPaused` and `whenPaused" + ], + [ + "applications may ", + "benefit from on-chain " + ], + [ + "make room", + " for the " + ], + [ + "mechanism that can be triggered by ", + "an authorized account" + ], + [ + "enumerability", + ", for those cases " + ], + [ + "daa952", + "ba7f" + ], + [ + "`, which can be appli", + "ed " + ], + [ + "bytes32[] memory store ", + "= _values(set._inner);\\n " + ], + [ + "df523", + "b3ef" + ], + [ + "Contract module which allows children to implement an emergency ", + "stop" + ], + [ + "The maximum value of a ", + "uint256 contains 78 digits (" + ], + [ + "fc378", + "daa952ba7f" + ], + [ + ". Note that they will not be ", + "pausable " + ], + [ + "32 bytes leftwards to ", + "make room for the " + ], + [ + "c2b068", + "fc378daa952ba7f" + ], + [ + "simply including ", + "this module, only once the " + ], + [ + "Cache the end of the memory ", + "to calculate the length " + ], + [ + "the address returned by `", + "_implementation()" + ], + [ + "0xddf252", + "ad1be2c89b69" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Returns true if the contract is paused, and ", + "false otherwise.\\n */\\n function paused(" + ], + [ + "CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof", + "} for details.\\n *\\n * _Available since v4.7._\\n */\\n function " + ], + [ + ". This is a lightweight ", + "version " + ], + [ + "whenNotPaused {\\n _paused = true;\\n emit ", + "Paused(" + ], + [ + "28f55a4", + "df523b3ef" + ], + [ + "leftmost digit.\\n // The following is essentially a do-while loop that also handles the zero case", + ".\\n // " + ], + [ + "members except through off-chain means ", + "by accessing the contract event log" + ], + [ + "the functions of your contract", + ". Note that they will not be pausable " + ], + [ + "163c4a116", + "28f55a4df523b3ef" + ], + [ + "modifiers `whenNotPaused` and `whenPaused", + "`, which can be applied " + ], + [ + "applications may benefit from on-chain ", + "enumerability, for those cases " + ], + [ + "The maximum value of a uint256 contains 78 digits (", + "1 byte per digit" + ], + [ + "c2b068fc378daa952ba7f", + "163c4a11628f55a4df523b3ef" + ], + [ + "simply including this module, only once the ", + "modifiers are put in plac" + ], + [ + "0xddf252ad1be2c89b69", + "c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef" + ], + [ + "applications may benefit from on-chain enumerability, for those cases ", + "see" + ], + [ + "\"", + "Max " + ], + [ + "(", + "config." + ], + [ + ".", + "\\r\\n *\\r\\n * " + ], + [ + "/", + "'" + ], + [ + "0", + " = " + ], + [ + "5", + "000" + ], + [ + "?", + " (" + ], + [ + "C", + "rowd" + ], + [ + "D", + "y" + ], + [ + "F", + "ul" + ], + [ + "I", + "RateProvider" + ], + [ + "N", + "eed" + ], + [ + "S", + "P" + ], + [ + "S", + "ince " + ], + [ + "U", + "Q" + ], + [ + "]", + " " + ], + [ + "_", + "throwError" + ], + [ + "_", + "efficientHash" + ], + [ + "_", + "withdrawableDividend" + ], + [ + "`", + "temp" + ], + [ + "b", + "n" + ], + [ + "b", + "ook" + ], + [ + "e", + "\"" + ], + [ + "i", + "] = _" + ], + [ + "m", + "i" + ], + [ + "m", + "im" + ], + [ + "r", + "yp" + ], + [ + "r", + ", r" + ], + [ + "s", + "oft" + ], + [ + "t", + "a " + ], + [ + "u", + "rn" + ], + [ + "v", + "ouch" + ], + [ + "\\n ", + ") internal view virtual returns (" + ], + [ + "re", + "ve" + ], + [ + "to", + ";\\n " + ], + [ + ", ", + "bytes calldata data" + ], + [ + "un", + "successful " + ], + [ + "un", + "pause() internal virtual whenPaused " + ], + [ + "function", + "s, and " + ], + [ + "address", + " " + ], + [ + ");", + "\\n // The " + ], + [ + "\\n ", + "let " + ], + [ + "is ", + "required to " + ], + [ + "\\n\\n ", + "constructor(" + ], + [ + "et", + "ch" + ], + [ + ") {", + "\\r\\n " + ], + [ + "su", + "mp" + ], + [ + "or ", + "when " + ], + [ + "transfer", + ".selector, to, value" + ], + [ + "lo", + "se" + ], + [ + "Transfer", + "Fee" + ], + [ + "\\n * ", + "mechanism that can be triggered by an authorized account" + ], + [ + "\\n * ", + "members except through off-chain means by accessing the contract event log" + ], + [ + "bu", + "t" + ], + [ + "in ", + "bytes32" + ], + [ + "for ", + "efficiency " + ], + [ + "if ", + "`account` is " + ], + [ + "ur", + "a" + ], + [ + "..", + "223" + ], + [ + "msgSender", + " == " + ], + [ + "as ", + "little " + ], + [ + "balance", + ", and " + ], + [ + "be", + "acon " + ], + [ + "cl", + "e " + ], + [ + ") public ", + "pure returns (" + ], + [ + "max", + "Tx" + ], + [ + "max", + "HoldingAmount" + ], + [ + "(uint256 ", + "assets" + ], + [ + "num", + "Minted" + ], + [ + "operator", + " == " + ], + [ + "this ", + "is not " + ], + [ + "swap", + " the " + ], + [ + "Requirements:", + "\\r\\n * - " + ], + [ + "interface", + "/" + ], + [ + "bool ", + "result" + ], + [ + "Bu", + "il" + ], + [ + "own", + "s it" + ], + [ + "balanceOf", + "(account" + ], + [ + "role", + "), 32" + ], + [ + "pre", + "fer" + ], + [ + "Int", + "ended to be " + ], + [ + "pl", + "an" + ], + [ + "Total", + ": " + ], + [ + ";\\n ", + "emit " + ], + [ + "; ", + "j" + ], + [ + "\\n */\\n function ", + "_check" + ], + [ + "\\n// ", + "This " + ], + [ + "s, ", + "avoid-call-value" + ], + [ + ".\\n * ", + "It is " + ], + [ + "_S", + "ECON" + ], + [ + "must be ", + "paused.\\n */\\n function _" + ], + [ + "must be ", + "paused.\\n */\\n modifier " + ], + [ + "::", + ":" + ], + [ + "][", + "_spender" + ], + [ + ");\\n }\\n\\n ", + "// =============================================================\\n // " + ], + [ + "Admin", + "ACL" + ], + [ + "Sta", + "ker" + ], + [ + "E_", + "T" + ], + [ + "we ", + "need to " + ], + [ + ",\\r\\n ", + "string memory " + ], + [ + "/EIP", + "712" + ], + [ + "Check", + "s" + ], + [ + "Po", + "ds" + ], + [ + "----------------", + "--------" + ], + [ + "De", + "fin" + ], + [ + "bool,", + "uint" + ], + [ + "total ", + "amount of " + ], + [ + "emit Transfer", + "(address(0), " + ], + [ + "defin", + "ed by `" + ], + [ + "_msgSender()", + ");\\n }\\n}\\n\"" + ], + [ + "Base", + "TokenURI" + ], + [ + ") internal pure returns (uint256) {\\n ", + "// " + ], + [ + "delet", + "ed " + ], + [ + "Block", + "Number" + ], + [ + "message ", + "including the " + ], + [ + "does not ", + "return " + ], + [ + "Limit", + "\"" + ], + [ + "Emitted when ", + "a " + ], + [ + ",\\n ", + "ERC721" + ], + [ + "if (!", + "hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit " + ], + [ + "values", + ".\\n // The " + ], + [ + "you ", + "need to " + ], + [ + ") internal {\\n ", + "// " + ], + [ + "revert(", + "\\n string(\\n abi.encodePacked(" + ], + [ + ");\\n require(", + "signer" + ], + [ + ".sol\\\";\\n\\n", + "/// @title " + ], + [ + "comp", + "ound" + ], + [ + ";\\r\\n ", + "bool public " + ], + [ + "pric", + "e of the " + ], + [ + "-= ", + "1; " + ], + [ + "Gen", + "ius" + ], + [ + "enum", + "eration" + ], + [ + "author", + ": " + ], + [ + "(\\n address target", + ",\\n bool " + ], + [ + "(address target, bytes memory data", + ") internal returns (bytes memory" + ], + [ + "UN", + "IS" + ], + [ + "to\\n * ", + "the functions of your contract. Note that they will not be pausable " + ], + [ + "sale", + "Config" + ], + [ + "the\\n * ", + "modifiers `whenNotPaused` and `whenPaused`, which can be applied " + ], + [ + "_ownership", + "s[tokenId" + ], + [ + ");\\n ", + "}\\n}\\n\"" + ], + [ + "\\n * ", + "using " + ], + [ + "_packedOwnership", + "Of(" + ], + [ + "\\t\\t", + "\\t" + ], + [ + "correspond", + "ing " + ], + [ + "EIP-", + "20 " + ], + [ + "that can be ", + "set " + ], + [ + "returns(", + "bool)" + ], + [ + ".\\n ", + "mstore8(" + ], + [ + "),", + "\\n \\\"" + ], + [ + "{\\n /**\\n * @dev ", + "Returns the " + ], + [ + "member", + "ship" + ], + [ + "excludeFromFees", + "(" + ], + [ + "160", + "..223" + ], + [ + "CE", + "SS" + ], + [ + " L", + "imit " + ], + [ + "Wrapp", + "er" + ], + [ + "desi", + "red" + ], + [ + "2, ", + "shl(" + ], + [ + "first", + "TokenId" + ], + [ + "from `", + "s" + ], + [ + "avoid", + "ing " + ], + [ + "ampl", + "ification " + ], + [ + "module is used through inheritance. It will make available ", + "the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied " + ], + [ + "_paused", + ";\\n\\n /**\\n * @dev Initializes the contract " + ], + [ + "swapBack", + "(" + ], + [ + "Auto", + "Liquify" + ], + [ + "isApprovedForAll(owner, ", + "_msgSenderERC721A())" + ], + [ + "Sp", + "ac" + ], + [ + "partic", + "ipant" + ], + [ + "pot", + "entially " + ], + [ + "`,", + "\\n // " + ], + [ + "by\\n * ", + "simply including this module, only once the modifiers are put in plac" + ], + [ + "ERC721Metadata", + "." + ], + [ + "Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be ", + "to transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer" + ], + [ + "). ", + "No " + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - The contract ", + "must not be " + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - The contract ", + "must be paused.\\n */\\n modifier " + ], + [ + "Emits a {Transfer", + "} event " + ], + [ + "withdrawable", + "Reward" + ], + [ + "histor", + "y" + ], + [ + ", created ", + "from `s" + ], + [ + "contract is paused", + ".\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n modifier " + ], + [ + "\\n * {", + "AccessControlEnumerable" + ], + [ + "respon", + "sible " + ], + [ + "imilar", + " to `" + ], + [ + "// F", + "ile @openzeppelin/contracts/" + ], + [ + "; ++i", + ") {\\n " + ], + [ + "log_", + "2, shl(" + ], + [ + "administr", + "ator" + ], + [ + "3F", + "))" + ], + [ + "127", + ", mul(" + ], + [ + "toHexString(uint256(", + "role), 32" + ], + [ + "Hal", + "f" + ], + [ + "token\\n * by either {approve} or {setApprovalForAll", + "}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n " + ], + [ + "amount exceeds balance\\\");\\n ", + "_totalSupply = _totalSupply.sub(amount);\\n emit Transfer" + ], + [ + " for a ", + "specific " + ], + [ + "change the ", + "starting token ID" + ], + [ + "=-=-=-=-", + "=-=-=-=-" + ], + [ + "an account ", + "has a " + ], + [ + "r := shr(", + "127, mul(" + ], + [ + "(uint8 ", + "decimals_" + ], + [ + "Deposi", + "tor" + ], + [ + "Returns an Ethereum Signed Message", + ", created from `s" + ], + [ + "token/ERC20/ERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20.sol\\\";\\nimport \\\"./extensions/IERC20Metadata.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.", + "zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general " + ], + [ + ";\\n uint8 ", + "private _decimals" + ], + [ + "Store the ", + "length" + ], + [ + "currentDelegate", + ", delegatee" + ], + [ + "\"@openzeppelin/contracts/utils/cryptography/", + "ECDSA.sol\"" + ], + [ + "ERC721Enumerable: ", + "global " + ], + [ + ") / _ONE", + ";\\n _expTable" + ], + [ + "Glob", + "al" + ], + [ + "rocket", + "Storage" + ], + [ + "ds-test", + "/src/\"" + ], + [ + "pause() internal virtual ", + "whenNotPaused {\\n _paused = true;\\n emit Paused(" + ], + [ + "state.\\n *\\n * Requirements:\\n *\\n * - The contract ", + "must not be paused.\\n */\\n function _" + ], + [ + "state.\\n *\\n * Requirements:\\n *\\n * - The contract ", + "must be paused.\\n */\\n function _" + ], + [ + "`account`.\\n */\\n event ", + "Unpaused(address account" + ], + [ + "`account`.\\n */\\n event ", + "Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by " + ], + [ + "hard", + "h" + ], + [ + "paused(), \\\"Pausable: ", + "paused" + ], + [ + ",\\n bool", + "[] calldata " + ], + [ + "cri", + "pt" + ], + [ + "log_2", + " := or(" + ], + [ + "unit", + "Balance" + ], + [ + ".\\n *\\n * This ", + "module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied " + ], + [ + "address[] memory path = new address[](", + "2);\\n " + ], + [ + "isApprovedForAll(owner, spender", + ")" + ], + [ + ";\\n require(c / a == b, \\\"SafeMath: multiplication overflow", + "\\\");\\n return c" + ], + [ + "let f := ", + "shr(128" + ], + [ + "_msgSender());\\n }\\n\\n /**\\n * @dev ", + "Returns to normal " + ], + [ + ";\\n }\\n\\n /**\\n * @dev Modifier to make a function callable only when the ", + "contract is not paused" + ], + [ + "lower than 0.5", + "%\"" + ], + [ + "liquid", + "ator" + ], + [ + "We will ", + "need " + ], + [ + "inline ", + "assembly" + ], + [ + "acros", + "s all " + ], + [ + "address(token", + ")." + ], + [ + "159", + "] " + ], + [ + "matur", + "ity" + ], + [ + "bytes32 structHash", + " = " + ], + [ + ".\\n if (address(", + "OPERATOR_FILTER_REGISTRY).code.length" + ], + [ + " = (_", + "expTable" + ], + [ + "32-byte word ", + "al" + ], + [ + "Contract module that allows children to implement role-based access\\n * control mechanisms", + ". This is a lightweight version " + ], + [ + "(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`", + "\\n *\\n * Emits a {Approval" + ], + [ + "let length", + " := sub(" + ], + [ + "that doesn't ", + "allow enumerating role" + ], + [ + "---------------------------------------------------------------------------------------------------------------", + "//\\n // " + ], + [ + ");\\n\\n bool private ", + "_paused;\\n\\n /**\\n * @dev Initializes the contract " + ], + [ + "0._", + "\\n */\\n function " + ], + [ + "maximum of ", + "78 digits. " + ], + [ + "_balances[account] = _balances[account].sub(amount, \\\"ERC20: burn ", + "amount exceeds balance\\\");\\n _totalSupply = _totalSupply.sub(amount);\\n emit Transfer" + ], + [ + "sequence ", + "of " + ], + [ + "_toString(tokenId))", + ") : " + ], + [ + "address owner,\\r\\n address ", + "spender" + ], + [ + "replay ", + "attack" + ], + [ + "ensure(", + "deadline" + ], + [ + "(\\r\\n address sender,\\r\\n address ", + "recipient,\\r\\n uint256 amount\\r\\n " + ], + [ + "{\\n // Ensure the sender is only the owner or contract itself.\\n _onlyOwnerOrSelf", + "();\\n\\n // " + ], + [ + "bytes memory return", + "data = " + ], + [ + "Update the free memory pointer to ", + "allocate" + ], + [ + "External interface of AccessControl ", + "declared to support ERC165 detection.\\n */\\ninterface IAccessControl" + ], + [ + "Triggers stopped ", + "state.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n function _" + ], + [ + "s. Some\\n * ", + "applications may benefit from on-chain enumerability, for those cases see" + ], + [ + "pause is triggered by ", + "`account`.\\n */\\n event Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by " + ], + [ + "Keep dividing ", + "`temp" + ], + [ + "to keep the free memory pointer ", + "32-byte word al" + ], + [ + "Contract module which allows children to implement an emergency stop", + "\\n * mechanism that can be triggered by an authorized account" + ], + [ + "unpause() internal virtual whenPaused ", + "{\\n _paused = false;\\n emit Unpaused(" + ], + [ + "\\n * members except through off-chain means by accessing the contract event log", + "s. Some\\n * applications may benefit from on-chain enumerability, for those cases see" + ], + [ + "message including the ", + "required role" + ], + [ + "if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit ", + "RoleGranted(role, account, _msgSender()" + ], + [ + "revert(\\n string(\\n abi.encodePacked(", + "\\n \\\"" + ], + [ + "UNIS", + "WAP" + ], + [ + "to\\n * the functions of your contract. Note that they will not be pausable ", + "by\\n * simply including this module, only once the modifiers are put in plac" + ], + [ + "_packedOwnershipOf(", + "index" + ], + [ + "160..223", + "] `" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - The contract must not be ", + "paused.\\n */\\n modifier whenNotPaused(" + ], + [ + "contract is paused.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n modifier ", + "whenPaused(" + ], + [ + "\\n * {AccessControlEnumerable", + "}.\\n *\\n * " + ], + [ + "r := shr(127, mul(", + "r, r" + ], + [ + "pause() internal virtual whenNotPaused {\\n _paused = true;\\n emit Paused(", + "_msgSender());\\n }\\n\\n /**\\n * @dev Returns to normal " + ], + [ + "state.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n function _", + "unpause() internal virtual whenPaused {\\n _paused = false;\\n emit Unpaused(" + ], + [ + "log_2 := or(", + "log_2, shl(" + ], + [ + ".\\n *\\n * This module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied ", + "to\\n * the functions of your contract. Note that they will not be pausable by\\n * simply including this module, only once the modifiers are put in plac" + ], + [ + "let f := shr(128", + ", r" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Modifier to make a function callable only when the contract is not paused", + ".\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n modifier whenNotPaused(" + ], + [ + ");\\n\\n bool private _paused;\\n\\n /**\\n * @dev Initializes the contract ", + "in unpaused state" + ], + [ + "maximum of 78 digits. ", + "Total: " + ], + [ + "Triggers stopped state.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n function _", + "pause() internal virtual whenNotPaused {\\n _paused = true;\\n emit Paused(_msgSender());\\n }\\n\\n /**\\n * @dev Returns to normal " + ], + [ + "pause is triggered by `account`.\\n */\\n event Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by ", + "`account`.\\n */\\n event Unpaused(address account" + ], + [ + "Keep dividing `temp", + "` until " + ], + [ + "Contract module which allows children to implement an emergency stop\\n * mechanism that can be triggered by an authorized account", + ".\\n *\\n * This module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\\n * the functions of your contract. Note that they will not be pausable by\\n * simply including this module, only once the modifiers are put in plac" + ], + [ + "\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see", + "\\n * {AccessControlEnumerable}.\\n *\\n * " + ], + [ + "Triggers stopped state.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n function _pause() internal virtual whenNotPaused {\\n _paused = true;\\n emit Paused(_msgSender());\\n }\\n\\n /**\\n * @dev Returns to normal ", + "state.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n function _unpause() internal virtual whenPaused {\\n _paused = false;\\n emit Unpaused(" + ], + [ + " ", + "at " + ], + [ + " ", + "with " + ], + [ + " ", + "exceeds the " + ], + [ + "\"", + "!" + ], + [ + "'", + "<" + ], + [ + "-", + "- " + ], + [ + "-", + "test" + ], + [ + ".", + "\\\");\\n require(" + ], + [ + ".", + "\\n\\n struct " + ], + [ + "/", + "Context" + ], + [ + "0", + ",\\n " + ], + [ + "1", + "E" + ], + [ + "5", + "%" + ], + [ + ";", + "\\n * }\\n * ```\\n *\\n * " + ], + [ + "A", + "IM" + ], + [ + "A", + ".selector ^ " + ], + [ + "B", + ".selector ^ " + ], + [ + "C", + "vx" + ], + [ + "G", + "O" + ], + [ + "G", + "oo" + ], + [ + "H", + "ow " + ], + [ + "M", + "et" + ], + [ + "M", + "ess" + ], + [ + "N", + "X" + ], + [ + "R", + "PC " + ], + [ + "]", + " `" + ], + [ + "_", + "1" + ], + [ + "_", + "i" + ], + [ + "_", + "nextTokenId" + ], + [ + "_", + "OUT" + ], + [ + "`", + "_currentIndex - " + ], + [ + "b", + "ps" + ], + [ + "c", + "4" + ], + [ + "e", + "7" + ], + [ + "f", + "ind" + ], + [ + "g", + "ov" + ], + [ + "s", + "ame as " + ], + [ + "s", + "niper" + ], + [ + "z", + " := " + ], + [ + "{", + "_setupDecimals" + ], + [ + " ", + "//\\n//" + ], + [ + "\\n", + "interface " + ], + [ + "ed", + ".\\n *\\n * " + ], + [ + "ac", + "ing\\n // " + ], + [ + ") ", + "calls." + ], + [ + "at", + "}." + ], + [ + "ent", + "inel" + ], + [ + "is", + "tic" + ], + [ + "em", + "ission" + ], + [ + "// ", + "Decl" + ], + [ + "uint256 ", + "lastIndex = " + ], + [ + "from", + ",\\n " + ], + [ + "Re", + "fe" + ], + [ + ".s", + "cript" + ], + [ + "value", + "." + ], + [ + " = ", + "msg.sender" + ], + [ + "Fee", + "s " + ], + [ + "Fee", + "Rate" + ], + [ + ");\\n ", + "} else {" + ], + [ + "in ", + "that " + ], + [ + "in ", + "constant " + ], + [ + "in ", + "storage to " + ], + [ + "in ", + "O(1), " + ], + [ + "for ", + "ownerOf(tokenId" + ], + [ + ". ", + "(" + ], + [ + ". ", + "For example" + ], + [ + "ERC721", + ", " + ], + [ + "and ", + "3 " + ], + [ + "and ", + "decrease " + ], + [ + "ur", + "ation " + ], + [ + "total", + "Tokens > " + ], + [ + "private ", + "my" + ], + [ + "private ", + "functions, and " + ], + [ + "..", + "191" + ], + [ + "..", + "127" + ], + [ + "ab", + "y" + ], + [ + "mint", + "Compli" + ], + [ + ") external ", + "onlyRole(" + ], + [ + "value ", + "of the " + ], + [ + "that ", + "fit" + ], + [ + "that ", + "means the " + ], + [ + "if (", + "curr < _currentIndex" + ], + [ + "po", + "se" + ], + [ + "ack", + "ed " + ], + [ + ") public ", + "returns (" + ], + [ + "Ex", + "ampl" + ], + [ + "a s", + "napshot " + ], + [ + "(uint256 ", + "packed" + ], + [ + "Ownership", + "At(uint256 index" + ], + [ + "This ", + "modifies the " + ], + [ + ", p", + "acked " + ], + [ + "code", + "\\n // " + ], + [ + "length", + "-1" + ], + [ + "with ", + "as little " + ], + [ + "are ", + "writing " + ], + [ + "e {", + "\\n * " + ], + [ + "totalSupply", + "() public view override returns (" + ], + [ + "Em", + "ergen" + ], + [ + "Bu", + "d" + ], + [ + "Recei", + "ved " + ], + [ + "balanceOf", + "(msg.sender" + ], + [ + "h ", + "from the " + ], + [ + "] = ", + "packed" + ], + [ + ") external view returns (", + "uint);\\n\\n function " + ], + [ + "\\\");\\n ", + "// " + ], + [ + "safe", + "96(" + ], + [ + "decimals", + "}, " + ], + [ + "\\n // ", + "in bytes32" + ], + [ + " the ", + "`" + ], + [ + "set ", + "state variable" + ], + [ + "0, ", + "Errors." + ], + [ + ":= ", + "aux" + ], + [ + "0 ", + "as a s" + ], + [ + "64", + " bits for `" + ], + [ + "64", + "..127" + ], + [ + "].", + "value = " + ], + [ + "ownership", + ".startTimestamp = uint64(" + ], + [ + ");\\n ", + "}\\n " + ], + [ + "Paus", + "able is Context " + ], + [ + ", and ", + "checked for " + ], + [ + "\"@openzeppelin/contracts/", + "token/ERC721/extensions/IERC721Enumerable" + ], + [ + "all ", + "indexes" + ], + [ + "}\\n ", + "}\\n\\n " + ], + [ + "use ", + "0 as a s" + ], + [ + "man", + "ual " + ], + [ + "ERC721A", + "(\\\"" + ], + [ + "128", + "..191" + ], + [ + ";\\r\\n", + "\\r\\n /**\\r\\n * @dev " + ], + [ + " and ", + "decrement the " + ], + [ + "block.timestamp", + " - " + ], + [ + "St", + "age " + ], + [ + "pool", + "s" + ], + [ + "s are ", + "constants " + ], + [ + ");\\r\\n ", + "_" + ], + [ + "we ", + "can only " + ], + [ + "we ", + "swap the " + ], + [ + "1 ", + "/ " + ], + [ + "Role(", + "role, " + ], + [ + "implementation", + "s (such as " + ], + [ + "library ", + "methods" + ], + [ + "indic", + "ates " + ], + [ + "To ", + "implement " + ], + [ + "To ", + "delete " + ], + [ + "s for ", + "types " + ], + [ + "code ", + "and " + ], + [ + "packed ", + "+= 1" + ], + [ + "packed ", + "-= 1; " + ], + [ + ".sol\\\";\\n\\n/**\\n * @dev ", + "This " + ], + [ + " := ", + "and(" + ], + [ + "It ", + "emits " + ], + [ + "chain", + "ID" + ], + [ + ", uint ", + "wad" + ], + [ + "type", + "hash" + ], + [ + "_get", + "Implementation" + ], + [ + "message ", + "sender (" + ], + [ + "excludeFrom", + "Limits" + ], + [ + "array", + ", as " + ], + [ + "array", + ", and then " + ], + [ + "from the ", + "\\\"main queue" + ], + [ + "struct", + "s " + ], + [ + "number of tokens ", + "to " + ], + [ + "to the ", + "index " + ], + [ + "ownership ", + "slot of tokenId" + ], + [ + "_balances[account", + "]" + ], + [ + "variant", + "s" + ], + [ + "Claim", + "Wait" + ], + [ + "user ", + "to " + ], + [ + "on the ", + "ordering" + ], + [ + "NFT", + " to " + ], + [ + "instead", + " of a " + ], + [ + "application", + "s that " + ], + [ + "}, ", + "initializes " + ], + [ + " ", + "IERC721" + ], + [ + "time", + "\\n * (" + ], + [ + "ed, ", + "we " + ], + [ + "comp", + "are the " + ], + [ + "slot ", + "where the " + ], + [ + "to a ", + "value " + ], + [ + "s.length", + "), s" + ], + [ + "If the ", + "ownership slot of tokenId" + ], + [ + "swapTokensForEth", + "(" + ], + [ + "delete ", + "is" + ], + [ + "delete ", + "with the last " + ], + [ + ", 1", + ")\\n // " + ], + [ + "\"// SPDX-License-Identifier: MIT\\n", + "pragma solidity >=" + ], + [ + "tx", + "Type" + ], + [ + "use {", + "_setupDecimals" + ], + [ + "initi", + "ator " + ], + [ + "_ownership", + "At(uint256 index" + ], + [ + "increment", + " and decrement the " + ], + [ + "uses ", + "private functions, and " + ], + [ + "gh", + "t to " + ], + [ + "permission", + "s " + ], + [ + "excludeFromMaxTransaction", + "(address(" + ], + [ + "Pre", + "viou" + ], + [ + "224", + "] `" + ], + [ + "Mask", + " of an " + ], + [ + "implementation ", + "uses private functions, and " + ], + [ + "Auth", + "ent" + ], + [ + "Default", + "s to " + ], + [ + "ownership.", + "burned = " + ], + [ + "default ", + "value of 18" + ], + [ + "// The ", + "interface ID" + ], + [ + "described in ", + "{" + ], + [ + "[from", + "] += " + ], + [ + "_msgSenderERC721A", + "() internal view virtual returns (" + ], + [ + "rel", + "ax" + ], + [ + "Initializes the ", + "ownership slot " + ], + [ + " is not ", + "explicitly " + ], + [ + ", we ", + "write it " + ], + [ + "enumer", + "ated in " + ], + [ + "\\n override", + "\\n returns (" + ], + [ + "set, ", + "that means the " + ], + [ + "Addition", + "al " + ], + [ + "element", + " of the " + ], + [ + "bpt", + "TotalSupply" + ], + [ + "number ", + "burned" + ], + [ + ")\\n // ", + "To delete " + ], + [ + ", uint256 index", + ") private view returns (" + ], + [ + "isContract(target), \\\"Address: ", + "call to non-contract" + ], + [ + "in packed ", + "address data " + ], + [ + " = 2", + "25" + ], + [ + "mask", + " of the " + ], + [ + "ick", + "ing a " + ], + [ + " is Context", + ", IAccessControl" + ], + [ + "() external pure returns (", + "bytes32" + ], + [ + "192", + "..255] `" + ], + [ + ";\\n }\\n\\n function _msgData() internal view virtual returns (", + "bytes memory" + ], + [ + "_approve(_msgSender(), ", + "spender, amount" + ], + [ + ");\\n\\n // ", + "Delete the " + ], + [ + "from `", + "packed" + ], + [ + "prevOwnershipPacked", + ")) != " + ], + [ + "types ", + "with as little " + ], + [ + "Update the ", + "index for the " + ], + [ + "`index` ", + "for efficiency " + ], + [ + " of the `", + "burned` " + ], + [ + "type ", + "with\\n // " + ], + [ + "for {", + "decimals}, " + ], + [ + "_packedAddressData", + "[to]" + ], + [ + "_packedAddressData", + "[from]" + ], + [ + ":\\n *\\n * ", + "- " + ], + [ + "ownership.addr", + " = address(uint160(" + ], + [ + "{decimals} ", + "with" + ], + [ + "removed", + ", and checked for " + ], + [ + "representing the ", + "first 4" + ], + [ + "O(1", + "))." + ], + [ + "Pos++", + "]" + ], + [ + "just ", + "wrapp" + ], + [ + "We can directly ", + "compare the " + ], + [ + "We can directly ", + "increment and decrement the " + ], + [ + "uint24 ", + "previousExtraData" + ], + [ + "guarantee", + "s are made " + ], + [ + "Position", + " of the " + ], + [ + "total number of tokens ", + "burned" + ], + [ + "stored at ", + "length-1" + ], + [ + ").\\n */\\n function _", + "contains(" + ], + [ + ").\\n */\\n function _", + "length(" + ], + [ + "this library ", + "for multiple " + ], + [ + "TX", + " Limit " + ], + [ + "+= 1", + "`." + ], + [ + "BITMASK_ADDRESS_DATA_ENTRY", + " = (1 << " + ], + [ + "BITPOS_START_TIMESTAMP", + " = 160" + ], + [ + "BITPOS_NUMBER_MINTED", + ") " + ], + [ + "BITPOS_NUMBER_MINTED", + " = 64" + ], + [ + "BITPOS_NUMBER_BURNED", + ";" + ], + [ + "BITPOS_NUMBER_BURNED", + ") " + ], + [ + "BITPOS_NUMBER_BURNED", + ") - 1" + ], + [ + "BITPOS_NUMBER_BURNED", + " = 128" + ], + [ + "(bool success, ) = recipient", + ".call{ value: amount " + ], + [ + "` array", + ", plus " + ], + [ + "address(uint160(", + "prevOwnershipPacked)) != " + ], + [ + "\\n ///", + " " + ], + [ + "go", + "o " + ], + [ + "uint _", + "amount" + ], + [ + ") public virtual override {\\n require(", + "account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * " + ], + [ + "select a different value ", + "for {decimals}, " + ], + [ + "es = ", + "new " + ], + [ + "BITMASK_NEXT_INITIALIZED", + " = 1 << " + ], + [ + "] `", + "numberBurned" + ], + [ + "+1", + ") calls." + ], + [ + "+1", + " is not explicitly " + ], + [ + "toDeleteIndex", + "] = " + ], + [ + " = (1 << ", + "192" + ], + [ + "Set the ", + "slot of tokenId" + ], + [ + "Move the ", + "last " + ], + [ + "s in the ", + "interface" + ], + [ + "s of a ", + "generic " + ], + [ + " = 5", + "000" + ], + [ + "initializer ", + "function " + ], + [ + "63", + "] " + ], + [ + "loan", + "ed" + ], + [ + "collect", + "ed" + ], + [ + "BITPOS_AUX", + " = 192" + ], + [ + "&&\\n ", + "!" + ], + [ + "BITPOS_NEXT_INITIALIZED", + " = 225" + ], + [ + "Wrapped", + "Token" + ], + [ + "entry ", + "in packed " + ], + [ + "BITMASK_BURNED", + " = 1 << " + ], + [ + "= _totalSupply", + ".add(amount);\\n _balances[account] = _balances[account].add(amount);\\n emit Transfer" + ], + [ + "function selector", + "s in the interface" + ], + [ + " value", + "\\n " + ], + [ + "ERC165 interface ID for ", + "ERC721Metadata." + ], + [ + "maintain correctness ", + "for ownerOf(tokenId" + ], + [ + "If you ", + "are writing " + ], + [ + "_startTokenId()", + "` " + ], + [ + "packed ownership ", + "data " + ], + [ + "This is equivalent to `", + "packed -= 1; " + ], + [ + "|| _", + "isExcludedFromFees[to]" + ], + [ + "Lin", + "k" + ], + [ + "225", + "] `" + ], + [ + "uint256) ", + "_indexes" + ], + [ + "token\\n * by either {approve} or {setApprovalForAll", + "}.\\n * - " + ], + [ + ") external;\\r\\n", + "\\r\\n function " + ], + [ + "order of the ", + "array, as " + ], + [ + "explicitly ", + "in storage to " + ], + [ + "multiplying ", + "by " + ], + [ + "_operatorApprovals[", + "_msgSenderERC721A()" + ], + [ + "stored", + "\\n " + ], + [ + "_AUX_COMPLEMENT", + " = (1 << 192" + ], + [ + "defaults to ", + "`msg.sender" + ], + [ + "GSN ", + "compatible " + ], + [ + "exclude", + "MultipleAccountsFromFees" + ], + [ + "Inst", + "ead" + ], + [ + "index for the ", + "deleted " + ], + [ + "ILL", + " " + ], + [ + "(\\n bytes32 hash,\\n bytes32 r,\\n bytes32 vs\\n ", + ") internal pure returns (address, RecoverError) {\\n bytes32 " + ], + [ + "(\\n bytes32 hash,\\n bytes32 r,\\n bytes32 vs\\n ", + ") internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, r, vs);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover" + ], + [ + "except the ", + "64 bits for `" + ], + [ + "(\\n bytes32 hash,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ", + ") internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, v, r, s);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Message, created from a `hash`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash" + ], + [ + "(\\n bytes32 hash,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ", + ") internal pure returns (address, RecoverError) {\\n // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\\n // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\\n //\\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\\n // these malleable signatures as well.\\n if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\\n return (address(0), RecoverError.InvalidSignatureS" + ], + [ + "decrement the ", + "balance, and " + ], + [ + "Delete the ", + "slot where the " + ], + [ + "// ERC165 interface ID for ", + "ERC165" + ], + [ + " = address(uint160(", + "prevOwnershipPacked" + ], + [ + "i.function", + "A.selector ^ " + ], + [ + "i.function", + "B.selector ^ " + ], + [ + "auxCasted ", + ":= aux" + ], + [ + "; // Updates: `balance ", + "-= 1" + ], + [ + "; // Updates: `balance ", + "+= 1`." + ], + [ + ") are ", + "just wrapp" + ], + [ + "remove the ", + "last " + ], + [ + "increment the ", + "number burned" + ], + [ + "during contract ", + "creation" + ], + [ + "contracts, ", + "you need to " + ], + [ + "present.\\n */\\n function _", + "remove(" + ], + [ + "$$ ", + "| " + ], + [ + "special", + "ization" + ], + [ + "toInt256", + "Safe" + ], + [ + "in {", + "at}." + ], + [ + ".\\n *\\n * NOTE: This ", + "information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals" + ], + [ + "block.timestamp <= ", + "deadline" + ], + [ + "means that ", + "we can only " + ], + [ + ";\\n *\\n * ", + "// Decl" + ], + [ + "&&\\r\\n ", + "!" + ], + [ + "_ownerOf", + "[id" + ], + [ + "`bytes4(", + "i.functionA.selector ^ " + ], + [ + ".sol)\\r\\n\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\n", + "/**\\r\\n * @dev " + ], + [ + "(\\n address sender,\\n address recipient,\\n uint256 amount\\n ) external returns (bool", + ");\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\"" + ], + [ + "fil", + "ter " + ], + [ + "in term", + "s of a generic " + ], + [ + ":= keccak256(0x", + "00, 0x" + ], + [ + "\"contracts/pendle", + "/contracts/" + ], + [ + "] != 0", + ";\\n }\\n\\n /**\\n * @dev Returns the number of " + ], + [ + ").\\n // ", + "This modifies the " + ], + [ + "noted ", + "in {at}." + ], + [ + "properties", + ":\\n *\\n * - " + ], + [ + "home/", + "dave/" + ], + [ + "upscale", + "Array(" + ], + [ + "existence ", + "in constant " + ], + [ + "There is ", + "no " + ], + [ + "interfaceId == 0x80ac58cd || ", + "// ERC165 interface ID for " + ], + [ + "interfaceId == 0x5b5e139f; // ", + "ERC165 interface ID for ERC721Metadata." + ], + [ + "_packedOwnerships[tokenId", + "] " + ], + [ + "1 to ", + "all indexes" + ], + [ + "864", + "00" + ], + [ + "EIP ", + "712 " + ], + [ + "minted at ", + "`index` for efficiency " + ], + [ + ".\\n // This ", + "means that we can only " + ], + [ + "\\n // and ", + "use 0 as a s" + ], + [ + " - 1;\\n ", + "uint256 lastIndex = " + ], + [ + "tryRecover(hash, v, r, s);\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\\n *\\n * _Available since v4.2._\\n */\\n function recover", + "(\\n bytes32 hash,\\n bytes32 r,\\n bytes32 vs\\n ) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, r, vs);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover" + ], + [ + ");\\n }\\n\\n // If the signature is valid (and not malleable), return the signer address\\n address signer = ecrecover(hash, v, r, s);\\n if (signer == address(0)) {\\n return (address(0), RecoverError.InvalidSignature);\\n }\\n\\n return (signer, RecoverError.NoError);\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n */\\n function recover", + "(\\n bytes32 hash,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, v, r, s);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Message, created from a `hash`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash" + ], + [ + ");\\n } else {\\n return (address(0), RecoverError.InvalidSignatureLength);\\n }\\n }\\n\\n /**\\n * @dev Returns the address that signed a hashed message (`hash`) with\\n * `signature`. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it.\\n */\\n function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, signature);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\\n *\\n * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover", + "(\\n bytes32 hash,\\n bytes32 r,\\n bytes32 vs\\n ) internal pure returns (address, RecoverError) {\\n bytes32 " + ], + [ + "\\n\\n uint256 ", + "toDeleteIndex" + ], + [ + "are a ", + "set state variable" + ], + [ + "slot\\n ", + "delete " + ], + [ + "{\\n /**\\n * @dev Emitted when the ", + "pause is triggered by `account`.\\n */\\n event Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by `account`.\\n */\\n event Unpaused(address account" + ], + [ + "added, ", + "removed, and checked for " + ], + [ + "sometimes ", + "called as " + ], + [ + "have the following ", + "properties:\\n *\\n * - " + ], + [ + "address payable) {\\n return msg.sender", + ";\\n }\\n\\n function _msgData() internal view virtual returns (bytes memory" + ], + [ + "O(n", + "). No " + ], + [ + "];\\n\\n ", + "return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev " + ], + [ + ", but we add ", + "1 to all indexes" + ], + [ + "+1 ", + "explicitly in storage to " + ], + [ + "// Stor", + "age of " + ], + [ + "_packedOwnerships[index] = ", + "_packedOwnershipOf(index" + ], + [ + "address is zero", + ", packed " + ], + [ + "repetition ", + "as possible" + ], + [ + "require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n ", + "address owner = ERC721.ownerOf(tokenId);\\n return (spender == owner || " + ], + [ + "// Add the ", + "library methods" + ], + [ + "zero.\\n ", + "temp := div(temp, 10" + ], + [ + "user-f", + "acing\\n // " + ], + [ + "_balances[sender] = _balances[sender].sub(amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n ", + "_balances[recipient] = _balances[recipient].add(amount);\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` " + ], + [ + "32 bytes leftwards to make room for the ", + "length.\\n " + ], + [ + "Cache the end of the memory to calculate the length ", + "later.\\n let end := " + ], + [ + "159] ", + "`addr" + ], + [ + "Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version ", + "that doesn't allow enumerating role" + ], + [ + "160..223] `", + "startTimestamp" + ], + [ + "Contract module which allows children to implement an emergency stop\\n * mechanism that can be triggered by an authorized account.\\n *\\n * This module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\\n * the functions of your contract. Note that they will not be pausable by\\n * simply including this module, only once the modifiers are put in plac", + "e.\\n */\\nabstract contract " + ], + [ + ";\\n * }\\n * ```\\n *\\n * ", + "As of " + ], + [ + "] `", + "numberMinted" + ], + [ + "`_currentIndex - ", + "_startTokenId()` " + ], + [ + "entinel", + " value\\n " + ], + [ + "in O(1), ", + "we swap the " + ], + [ + "that fit", + "\\n // in bytes32" + ], + [ + "Exampl", + "e {\\n * " + ], + [ + "code\\n // ", + "repetition as possible" + ], + [ + "64..127", + "] `numberMinted" + ], + [ + "128..191", + "] `numberBurned" + ], + [ + "s are constants ", + "representing the first 4" + ], + [ + "To implement ", + "this library for multiple " + ], + [ + "s for types ", + "that fit\\n // in bytes32" + ], + [ + "message sender (", + "defaults to `msg.sender" + ], + [ + "array, and then ", + "remove the last " + ], + [ + "to the index ", + "where the " + ], + [ + "on the ordering", + ".\\n *\\n * " + ], + [ + "}, initializes ", + "{decimals} with" + ], + [ + "time\\n * (", + "O(1))." + ], + [ + "If the ownership slot of tokenId", + "+1 is not explicitly " + ], + [ + "initiator ", + "owns it" + ], + [ + "224] `", + "burned" + ], + [ + "Mask of an ", + "entry in packed " + ], + [ + "implementation uses private functions, and ", + "user-facing\\n // " + ], + [ + "// The interface ID", + "s are constants representing the first 4" + ], + [ + "Initializes the ownership slot ", + "minted at `index` for efficiency " + ], + [ + ", we write it ", + "in terms of a generic " + ], + [ + "enumerated in ", + "O(n). No " + ], + [ + "in packed address data ", + "except the 64 bits for `" + ], + [ + "192..255] `", + "aux" + ], + [ + ");\\n\\n // Delete the ", + "index for the deleted " + ], + [ + "types with as little ", + "code\\n // repetition as possible" + ], + [ + "Update the index for the ", + "moved " + ], + [ + "type with\\n // ", + "bytes32 " + ], + [ + "_packedAddressData[to]", + "; // Updates: `balance += 1`." + ], + [ + "_packedAddressData[from]", + "; // Updates: `balance -= 1" + ], + [ + "ownership.addr = address(uint160(", + "packed" + ], + [ + "We can directly compare the ", + "packed " + ], + [ + "We can directly increment and decrement the ", + "balances" + ], + [ + "guarantees are made ", + "on the ordering.\\n *\\n * " + ], + [ + "stored at length-1", + ", but we add 1 to all indexes" + ], + [ + "BITMASK_ADDRESS_DATA_ENTRY = (1 << ", + "64" + ], + [ + "` array, plus ", + "1" + ], + [ + "select a different value for {decimals}, ", + "use {_setupDecimals" + ], + [ + "BITMASK_NEXT_INITIALIZED = 1 << ", + "225" + ], + [ + "Set the slot of tokenId", + "+1 explicitly in storage to " + ], + [ + "63] ", + "`balance" + ], + [ + "BITMASK_BURNED = 1 << ", + "224" + ], + [ + "maintain correctness for ownerOf(tokenId", + "+1) calls." + ], + [ + "If you are writing ", + "GSN compatible " + ], + [ + "This is equivalent to `packed -= 1; ", + "packed += 1" + ], + [ + "225] `", + "nextInitialized" + ], + [ + "order of the array, as ", + "noted in {at}." + ], + [ + "decrement the balance, and ", + "increment the number burned" + ], + [ + "Delete the slot where the ", + "moved " + ], + [ + "i.functionB.selector ^ ", + "..." + ], + [ + ") are just wrapp", + "ers " + ], + [ + "contracts, you need to ", + "override this function" + ], + [ + ";\\n *\\n * // Decl", + "are a set state variable" + ], + [ + "`bytes4(i.functionA.selector ^ ", + "i.functionB.selector ^ ..." + ], + [ + ").\\n // This modifies the ", + "order of the array, as noted in {at}." + ], + [ + "existence in constant ", + "time\\n * (O(1))." + ], + [ + ".\\n // This means that we can only ", + "create new " + ], + [ + "\\n // and use 0 as a s", + "entinel value\\n " + ], + [ + "tryRecover(hash, v, r, s);\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\\n *\\n * _Available since v4.2._\\n */\\n function recover(\\n bytes32 hash,\\n bytes32 r,\\n bytes32 vs\\n ) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, r, vs);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover", + "(\\n bytes32 hash,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal pure returns (address, RecoverError) {\\n // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\\n // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\\n //\\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\\n // these malleable signatures as well.\\n if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\\n return (address(0), RecoverError.InvalidSignatureS" + ], + [ + ");\\n }\\n\\n // If the signature is valid (and not malleable), return the signer address\\n address signer = ecrecover(hash, v, r, s);\\n if (signer == address(0)) {\\n return (address(0), RecoverError.InvalidSignature);\\n }\\n\\n return (signer, RecoverError.NoError);\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n */\\n function recover(\\n bytes32 hash,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, v, r, s);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Message, created from a `hash`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash", + "(bytes32 hash) internal pure returns (bytes32) {\\n // 32 is the length in bytes of hash,\\n // enforced by the type signature above\\n return keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n32\\\", hash" + ], + [ + "{\\n /**\\n * @dev Emitted when the pause is triggered by `account`.\\n */\\n event Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by `account`.\\n */\\n event Unpaused(address account", + ");\\n\\n bool private _paused;\\n\\n /**\\n * @dev Initializes the contract in unpaused state" + ], + [ + "added, removed, and checked for ", + "existence in constant time\\n * (O(1))." + ], + [ + "// Add the library methods", + "\\n * using " + ], + [ + "Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role", + "\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * " + ], + [ + "Example {\\n * ", + "// Add the library methods\\n * using " + ], + [ + "To implement this library for multiple ", + "types with as little code\\n // repetition as possible" + ], + [ + "s for types that fit\\n // in bytes32", + ".\\n\\n struct " + ], + [ + "If the ownership slot of tokenId+1 is not explicitly ", + "set, that means the " + ], + [ + "implementation uses private functions, and user-facing\\n // ", + "implementations (such as " + ], + [ + "Initializes the ownership slot minted at `index` for efficiency ", + "purposes" + ], + [ + "enumerated in O(n). No ", + "guarantees are made on the ordering.\\n *\\n * " + ], + [ + "in packed address data except the 64 bits for `", + "aux" + ], + [ + ");\\n\\n // Delete the index for the deleted ", + "slot\\n delete " + ], + [ + "stored at length-1, but we add 1 to all indexes", + "\\n // and use 0 as a sentinel value\\n " + ], + [ + "Set the slot of tokenId+1 explicitly in storage to ", + "maintain correctness for ownerOf(tokenId+1) calls." + ], + [ + "If you are writing GSN compatible ", + "contracts, you need to override this function" + ], + [ + ";\\n *\\n * // Declare a set state variable", + "\\n * " + ], + [ + ").\\n // This modifies the order of the array, as noted in {at}.", + "\\n\\n uint256 toDeleteIndex" + ], + [ + "added, removed, and checked for existence in constant time\\n * (O(1)).", + "\\n * - " + ], + [ + "To implement this library for multiple types with as little code\\n // repetition as possible", + ", we write it in terms of a generic " + ], + [ + "!", + "is" + ], + [ + "\"", + "Account is already " + ], + [ + "\"", + "TX Limit " + ], + [ + "'", + " and " + ], + [ + "(", + "uniswapV2Pair" + ], + [ + "(", + "totalSupply() * " + ], + [ + ",", + "\\n\\t\\t" + ], + [ + "1", + ") " + ], + [ + "4", + "\\\"" + ], + [ + "A", + "a" + ], + [ + "I", + "R" + ], + [ + "I", + "mit" + ], + [ + "I", + "Asset " + ], + [ + "I", + "UniswapV3Pool" + ], + [ + "M", + "GDC" + ], + [ + "R", + "NG" + ], + [ + "W", + "ILL " + ], + [ + "[", + "proof" + ], + [ + "_", + "fictiveReserve" + ], + [ + "_", + "matron" + ], + [ + "`", + "), " + ], + [ + "a", + "w" + ], + [ + "g", + "in " + ], + [ + "o", + "ta" + ], + [ + "p", + "i" + ], + [ + "s", + "))" + ], + [ + "s", + "ame" + ], + [ + "z", + "el" + ], + [ + "}", + "\\n // " + ], + [ + "}", + "\\r\\n " + ], + [ + "er", + "al" + ], + [ + "to", + "UInt" + ], + [ + "in", + "ce\\n // " + ], + [ + "ro", + "nt" + ], + [ + "uint256", + ");\\n function " + ], + [ + "uint256", + ") {\\n return " + ], + [ + "return", + "ing " + ], + [ + "\\n * ", + "this " + ], + [ + "or", + "\\n * " + ], + [ + "function", + "Selector" + ], + [ + ") ", + "to " + ], + [ + ") ", + "&& " + ], + [ + ") ", + "% " + ], + [ + "address", + ")\\\", p0, p1, p2, p3));\\n\\t}\\n\\n\\tfunction log(bool " + ], + [ + "ing", + ", " + ], + [ + ");", + "\\n // " + ], + [ + "token", + " = " + ], + [ + "token", + "'s " + ], + [ + "ed ", + "during " + ], + [ + "function ", + "call to " + ], + [ + "a ", + "regular " + ], + [ + "` ", + "before " + ], + [ + "uint256 ", + "prevOwnershipPacked = _packedOwnershipOf(tokenId" + ], + [ + ": ", + "must have " + ], + [ + ") {", + "\\r\\n" + ], + [ + "bool", + ")\\\", p0, p1, p2, p3));\\n\\t}\\n\\n\\tfunction log(bool " + ], + [ + ".s", + "y" + ], + [ + "call", + " (i.e. " + ], + [ + "ERC20", + ", IERC20" + ], + [ + ".\\n *\\n * ", + "Requirements:\\n * - " + ], + [ + "\\n * ", + "types" + ], + [ + "return ", + "value: " + ], + [ + "return ", + "_currentIndex - " + ], + [ + ",\\n ", + "Rounding rounding" + ], + [ + "public ", + "drop " + ], + [ + "if ", + "data is " + ], + [ + "ev", + "en" + ], + [ + ". ", + "Note " + ], + [ + ". ", + "At the " + ], + [ + "In", + "iti" + ], + [ + "ation", + "ale" + ], + [ + "con", + "vex" + ], + [ + "it ", + "ourselves" + ], + [ + "\\n ", + "require(" + ], + [ + "), ", + "relax" + ], + [ + "\\r\\n ", + "if (" + ], + [ + "string", + ")\\\", p0, p1, p2, p3));\\n\\t}\\n\\n\\tfunction log(bool " + ], + [ + "ff", + "ect " + ], + [ + "The ", + "contract " + ], + [ + "up", + "dating" + ], + [ + ", p", + "ay" + ], + [ + "length", + ",\\n // " + ], + [ + "operator", + ",\\n bool approved" + ], + [ + "}\\n", + "}\\n\\n" + ], + [ + ").", + "call{value: " + ], + [ + "not be ", + "false" + ], + [ + " ", + " " + ], + [ + " (", + "but " + ], + [ + ",\\n uint256 ", + "balance" + ], + [ + "10", + "10" + ], + [ + "cannot be ", + "changed " + ], + [ + "tokens", + "ToAddLiquidityWith" + ], + [ + ".\\n */\\n function _", + "toString" + ], + [ + "Un", + "it" + ], + [ + "See {", + "ERC20-" + ], + [ + "_approve", + "(account, " + ], + [ + "abi.", + "encode " + ], + [ + "))", + "\\r\\n " + ], + [ + "constructor", + ". " + ], + [ + "Pro", + "gram" + ], + [ + "sell", + "Taxes" + ], + [ + "s to ", + "add " + ], + [ + "typ", + "ed " + ], + [ + "tax", + "es" + ], + [ + "out ", + "of the " + ], + [ + "interface ", + "IUniswapV2Router02" + ], + [ + "Lo", + "ss" + ], + [ + ", uint256 amount", + "1" + ], + [ + "non-", + "fungible " + ], + [ + "read", + "able " + ], + [ + "Wh", + "iteList" + ], + [ + "(address owner", + ", uint256 " + ], + [ + "Admin", + "(address " + ], + [ + "pool", + "s " + ], + [ + "two ", + "values" + ], + [ + "uint16", + "8" + ], + [ + "ing the ", + "requirement" + ], + [ + "gas ", + "error" + ], + [ + "Ac", + "cept" + ], + [ + "\\n *", + "\\n * @param " + ], + [ + "version", + "` is " + ], + [ + "Solidity ", + "high" + ], + [ + "####", + "#" + ], + [ + " = _", + "get" + ], + [ + "alread", + "y" + ], + [ + "mechanism", + ", s" + ], + [ + "decre", + "as" + ], + [ + "` operator", + ".\\n *\\n * Requirements:\\n * - " + ], + [ + "plac", + "es" + ], + [ + "e. ", + "The " + ], + [ + ", it ", + "can be " + ], + [ + "payable ", + "_" + ], + [ + "registrant", + "'s " + ], + [ + "via ", + "`" + ], + [ + "dur", + "ation " + ], + [ + "dur", + "ing the " + ], + [ + "limit", + "ed " + ], + [ + "\\n /// @param ", + "tick" + ], + [ + "████", + "██" + ], + [ + "on the ", + "return value: " + ], + [ + "an address ", + "which " + ], + [ + "Man", + "y" + ], + [ + "a contract", + "), relax" + ], + [ + "revert(", + "0, " + ], + [ + "}, ", + "as " + ], + [ + "}.\\n *\\n * ", + "All three of these values are immutable: they can only be set once during\\n * construction" + ], + [ + "permit", + "(address owner, address spender" + ], + [ + "_F", + "ROM" + ], + [ + "bel", + "ow the " + ], + [ + "Role(bytes32 role", + ") {\\n _check" + ], + [ + "Convert", + "s a " + ], + [ + "config", + "ID" + ], + [ + "over ", + "``owner``'s " + ], + [ + "max ", + "transaction " + ], + [ + "locked", + "_stake" + ], + [ + "(address account, uint256 amount", + ") internal virtual {\\r\\n require(" + ], + [ + "value is ", + "optional" + ], + [ + "tokenIds", + "Length" + ], + [ + ", it must ", + "not be false" + ], + [ + "size ", + "checking " + ], + [ + "Rati", + "o " + ], + [ + "allowance(address owner, address spender", + ") external view returns (uint256" + ], + [ + "math/", + "SafeCast" + ], + [ + "specific ", + "role. " + ], + [ + "\\\");\\r\\n ", + "_" + ], + [ + "\\\");\\r\\n ", + "unchecked {\\r\\n " + ], + [ + ";\\n\\n // ", + "Check " + ], + [ + ";\\n uint256 internal constant ", + "UN" + ], + [ + ");\\n if (", + "to.code.length != 0" + ], + [ + "{IERC20-approve}", + ", the " + ], + [ + "_add", + "Pauser" + ], + [ + "Creator", + "PaymentAddress" + ], + [ + "(bool success, bytes memory returndata) = target", + ".call{value: value}" + ], + [ + "assum", + "ed to " + ], + [ + "part ", + "of the " + ], + [ + "DEFAULT", + "_SUBSCRIPTION" + ], + [ + ";\\r\\n\\r\\n ", + "uint256 public " + ], + [ + "blockNumber", + "`, " + ], + [ + "lab", + "or" + ], + [ + "wallet ", + "size" + ], + [ + ".sol\\\";\\nimport \\\"../", + "extensions/" + ], + [ + " bits ", + "for " + ], + [ + "intermedi", + "ate " + ], + [ + "with a ", + "standardized " + ], + [ + ") {\\r\\n ", + "return " + ], + [ + "propos", + "al " + ], + [ + "Calcul", + "ate " + ], + [ + "\\n\\n // ", + "We write the string " + ], + [ + "Info ", + "storage " + ], + [ + "on fail", + "ure " + ], + [ + "\\n ) internal pure returns (", + "uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0))\\n prod0 := mul(x, y)\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1" + ], + [ + "minimum", + "TokensBeforeSwap" + ], + [ + "| |", + "_" + ], + [ + "airdrop", + "Address" + ], + [ + "Bit", + "Map storage " + ], + [ + "here", + ", to " + ], + [ + "limitsInE", + "ffect " + ], + [ + "structu", + "red " + ], + [ + "requen", + "cy " + ], + [ + "numberOf", + "Tokens " + ], + [ + "_initializ", + "ed" + ], + [ + "keccak256(bytes(", + "version" + ], + [ + "product", + " * " + ], + [ + "epoch", + "s[" + ], + [ + "currOwnershipAddr", + " == owner" + ], + [ + ") {\\n if (", + "returndata.length" + ], + [ + "(uint16 _", + "dstChainId" + ], + [ + "low level call ", + "here, to " + ], + [ + "TokenOwnership memory ", + "prevOwnership" + ], + [ + "t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general ", + "OpenZeppelin Contracts guidelines: functions revert\\n * instead returning `false` on failure. This behavior is nonetheless\\n * conventional and does not conflict with the expectations of ERC20\\n * applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping(address => uint256) private _balances;\\n\\n mapping(address => mapping(address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The default value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5.05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address to, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _transfer(owner, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``from``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 amount\\n ) public virtual override returns (bool) {\\n address spender = _msgSender();\\n _spendAllowance(from, spender, amount);\\n _transfer(from, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, allowance(owner, spender) + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n uint256 currentAllowance = allowance(owner, spender);\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - subtractedValue);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves `amount` of tokens from `from` to `to`.\\n *\\n * This internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {\\n require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(to != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, amount);\\n\\n uint256 fromBalance = _balances[from];\\n require(fromBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n unchecked {\\n _balances[from] = fromBalance - amount" + ], + [ + "empty", + "-" + ], + [ + "isOperator", + "Allowed(" + ], + [ + "disabl", + "ed " + ], + [ + "Mut", + "ant" + ], + [ + "Struc", + "ts" + ], + [ + ")\\n public\\n view\\n virtual\\n override", + "\\n returns (" + ], + [ + "Input", + "Length" + ], + [ + ")\\n }\\n ", + "} else {\\n " + ], + [ + "increase ", + "and decrease " + ], + [ + "\"// SPDX-License-Identifier: GPL-3.0-or-later\\n// This program is free software: you can redistribute it and/or modify\\n// it under the terms of the GNU General Public License as published by\\n// the Free Software Foundation, either version 3 of the License, or\\n// (at your option) any later version.\\n\\n// This program is distributed in the hope that it will be useful,\\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\n// GNU General Public License for more details.\\n\\n// You should have received a copy of the GNU General Public License\\n// along with this program. If not, see .\\n\\npragma solidity ^0.7.0", + ";\\n\\nimport \\\"@balancer-labs/v2-" + ], + [ + "onERC721Received(\\n address operator,\\n address from,\\n uint256 tokenId,\\n bytes calldata data\\n ) external returns (bytes4", + ");\\n}\\n\\n" + ], + [ + "Gobbl", + "ers" + ], + [ + ")\\n\\n // ", + "Cache the end of the memory to calculate the length later.\\n let end := " + ], + [ + ") | (", + "auxCasted " + ], + [ + "for {permit", + "}, as " + ], + [ + "_AUX_COMPLEMENT", + ") | (auxCasted " + ], + [ + "Boost", + "er" + ], + [ + "_address ", + "= _" + ], + [ + ";\\n\\n mapping (address => ", + "mapping (address => uint256" + ], + [ + "implementing ", + "it ourselves" + ], + [ + "meaning ", + "of `" + ], + [ + "ates a ", + "Solidity high" + ], + [ + "(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n ", + "if (b == 0) return (false, 0);\\n return (true, " + ], + [ + ".\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator", + ",\\n Rounding rounding" + ], + [ + ".\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator", + "\\n ) internal pure returns (uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0))\\n prod0 := mul(x, y)\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1" + ], + [ + "the return ", + "value is optional" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// ERC721A Contracts v4.2.3\\n// Creator: Chiru Labs\\n\\npragma solidity ^0.8.4", + ";\\n\\nimport './IERC721A" + ], + [ + ", amounts", + "In" + ], + [ + "sqrtRatio", + "AX96" + ], + [ + "eq(msgSender", + ", " + ], + [ + "-level ", + "call (i.e. " + ], + [ + "owner query for nonexistent token", + "\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (" + ], + [ + "divisor", + "Index" + ], + [ + "returned", + ", it must not be false" + ], + [ + ", ERC165 {\\n struct ", + "RoleData {\\n " + ], + [ + "perman", + "ently " + ], + [ + "We need to ", + "perform a " + ], + [ + ") >> 128", + ";\\n if (absTick & 0x" + ], + [ + "Revert with a standard message ", + "if `account` is " + ], + [ + "return data ", + "size checking " + ], + [ + "(\\n address seaDropImpl", + ",\\n address " + ], + [ + " == 0) {\\n return ", + "prod0 / denominator;\\n }\\n\\n // Make sure the result is less than 2^256. Also prevents denominator == 0.\\n require(denominator > prod1" + ], + [ + "Strings.toString(", + "s.length), s" + ], + [ + "`tokenId` has been\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` has been minted for `to`.\\n * - When `to` is zero, `tokenId` has been burned by `from`.\\n * - `from` and `to` are never both zero.\\n */\\n function _afterTokenTransfers(\\n address from,\\n address to,\\n uint256 startTokenId,\\n uint256 quantity\\n ", + ") internal virtual {}\\n\\n /**\\n * @dev " + ], + [ + "no-", + "empty-" + ], + [ + "out-of-", + "gas error" + ], + [ + ");\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator)\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder)\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function.\\n uint256 twos = denominator & (~denominator + 1);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1)\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step.\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction", + ".\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator,\\n Rounding rounding" + ], + [ + "decimal representation", + ".\\n */\\n function _toString" + ], + [ + "curr = tokenId;\\n\\n unchecked {\\n if (_startTokenId() <= ", + "curr" + ], + [ + "cleared", + "Word " + ], + [ + "_src", + "Address, uint64 _nonce" + ], + [ + "checks that ", + "an account has a " + ], + [ + "Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param _data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received", + "(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes memory _data\\n ) private returns (bool) {\\n " + ], + [ + "Direct", + "ly " + ], + [ + "_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, \\\"ERC20: decreased allowance below zero\\\")", + ");\\n return true;\\n }\\n\\n /**\\n * @dev " + ], + [ + ") internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data", + "), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n " + ], + [ + "substraction", + " of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub" + ], + [ + "mintingAllowed", + "After" + ], + [ + ") public view virtual returns (bool) {\\n return _", + "paused" + ], + [ + "Modifier that ", + "checks that an account has a " + ], + [ + "keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n\\\", ", + "Strings.toString(s.length), s" + ], + [ + "hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit ", + "RoleRevoked(role, account, _msgSender());\\n }\\n }\\n}\\n\"" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Returns true if the contract is paused, and false otherwise.\\n */\\n function paused(", + ") public view virtual returns (bool) {\\n return _paused" + ], + [ + "sump", + "tion" + ], + [ + "),\\n \\\"", + " is missing role " + ], + [ + "toHexString(uint256(role), 32", + ")\\n )\\n )\\n " + ], + [ + "Keep dividing `temp` until ", + "zero.\\n temp := div(temp, 10" + ], + [ + "Triggers stopped state.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n function _pause() internal virtual whenNotPaused {\\n _paused = true;\\n emit Paused(_msgSender());\\n }\\n\\n /**\\n * @dev Returns to normal state.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n function _unpause() internal virtual whenPaused {\\n _paused = false;\\n emit Unpaused(", + "_msgSender());\\n }\\n}\\n\"" + ], + [ + "Pausable is Context ", + "{\\n /**\\n * @dev Emitted when the pause is triggered by `account`.\\n */\\n event Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by `account`.\\n */\\n event Unpaused(address account);\\n\\n bool private _paused;\\n\\n /**\\n * @dev Initializes the contract in unpaused state" + ], + [ + "\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable", + ".sol\"" + ], + [ + " is Context, IAccessControl", + ", ERC165 {\\n struct RoleData {\\n " + ], + [ + "`bytes4(i.functionA.selector ^ i.functionB.selector ^ ...", + ")`" + ], + [ + "\"TX Limit ", + "Exceeded\"" + ], + [ + "Imit", + "ates a Solidity high" + ], + [ + "function call to ", + "a contract), relax" + ], + [ + "a regular ", + "function call to a contract), relax" + ], + [ + "if data is ", + "returned, it must not be false" + ], + [ + " (but ", + "if data is returned, it must not be false" + ], + [ + "on the return value: ", + "the return value is optional" + ], + [ + "(address account, uint256 amount) internal virtual {\\r\\n require(", + "account != address(0), \\\"ERC20: " + ], + [ + "specific role. ", + "Revert" + ], + [ + ");\\n if (to.code.length != 0", + ")\\n if (!" + ], + [ + "with a standardized ", + "message including the required role" + ], + [ + "BitMap storage ", + "bitmap" + ], + [ + "low level call here, to ", + "bypass " + ], + [ + "t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\\n * instead returning `false` on failure. This behavior is nonetheless\\n * conventional and does not conflict with the expectations of ERC20\\n * applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping(address => uint256) private _balances;\\n\\n mapping(address => mapping(address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The default value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5.05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address to, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _transfer(owner, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``from``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 amount\\n ) public virtual override returns (bool) {\\n address spender = _msgSender();\\n _spendAllowance(from, spender, amount);\\n _transfer(from, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, allowance(owner, spender) + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n uint256 currentAllowance = allowance(owner, spender);\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - subtractedValue);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves `amount` of tokens from `from` to `to`.\\n *\\n * This internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {\\n require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(to != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, amount);\\n\\n uint256 fromBalance = _balances[from];\\n require(fromBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n unchecked {\\n _balances[from] = fromBalance - amount", + ";\\n // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\\n // decrementing then incrementing.\\n _balances[to] += amount;\\n }\\n\\n emit Transfer(from, to, amount);\\n\\n _afterTokenTransfer(from, to, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n unchecked {\\n // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\\n _balances[account] += amount;\\n }\\n emit Transfer(address(0), account, amount);\\n\\n _afterTokenTransfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n unchecked {\\n _balances[account] = accountBalance - amount;\\n // Overflow not possible: amount <= accountBalance <= totalSupply.\\n _totalSupply -= amount;\\n }\\n\\n emit Transfer" + ], + [ + ".\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator\\n ) internal pure returns (uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0))\\n prod0 := mul(x, y)\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1", + " == 0) {\\n return prod0 / denominator;\\n }\\n\\n // Make sure the result is less than 2^256. Also prevents denominator == 0.\\n require(denominator > prod1" + ], + [ + "-level call (i.e. ", + "a regular function call to a contract), relax" + ], + [ + "owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (", + "string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n " + ], + [ + "We need to perform a ", + "low level call here, to bypass " + ], + [ + "Revert with a standard message if `account` is ", + "missing `role" + ], + [ + "return data size checking ", + "mechanism, s" + ], + [ + ");\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator)\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder)\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function.\\n uint256 twos = denominator & (~denominator + 1);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1)\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step.\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator,\\n Rounding rounding", + "\\n " + ], + [ + "Modifier that checks that an account has a ", + "specific role. Revert" + ], + [ + "Imitates a Solidity high", + "-level call (i.e. a regular function call to a contract), relax" + ], + [ + "on the return value: the return value is optional", + " (but if data is returned, it must not be false" + ], + [ + "Imitates a Solidity high-level call (i.e. a regular function call to a contract), relax", + "ing the requirement" + ], + [ + "\"", + "$" + ], + [ + "\"", + "D" + ], + [ + "(", + "uint256[] calldata " + ], + [ + ")", + "\\r\\n {\\r\\n " + ], + [ + "2", + "981" + ], + [ + "=", + "\\n " + ], + [ + ">", + "0)" + ], + [ + "B", + "oring" + ], + [ + "F", + "9" + ], + [ + "I", + "ERC2309" + ], + [ + "M", + "on" + ], + [ + "O", + "f " + ], + [ + "T", + "elegram" + ], + [ + "X", + "EN" + ], + [ + "_", + "day" + ], + [ + "_", + "deposit" + ], + [ + "_", + "interest" + ], + [ + "e", + "4" + ], + [ + "f", + "4" + ], + [ + "m", + "on" + ], + [ + "n", + "\\u0027" + ], + [ + "s", + "Per" + ], + [ + "s", + "\\r\\n * " + ], + [ + "w", + "stETH" + ], + [ + "re", + "ven" + ], + [ + "s ", + "{" + ], + [ + "\\n ", + "assembly { " + ], + [ + "\\n ", + "/// @solidity memory-safe-assembly\\n assembly {\\n " + ], + [ + "to ", + "prevent" + ], + [ + "as", + "on" + ], + [ + "cont", + "ain the " + ], + [ + "su", + "re" + ], + [ + "el", + "eg" + ], + [ + "20", + ", " + ], + [ + "Re", + "b" + ], + [ + "Re", + "fl" + ], + [ + "or ", + "one " + ], + [ + "an ", + "already " + ], + [ + "if", + "t" + ], + [ + "Transfer", + "s" + ], + [ + ".\\n */\\n function ", + "_msgSenderERC721A() internal view virtual returns (" + ], + [ + ");\\n ", + "ownership.burned = " + ], + [ + "--", + "_packedAddressData[from]; // Updates: `balance -= 1" + ], + [ + "if ", + "target " + ], + [ + "if ", + "the call " + ], + [ + ") internal ", + "{" + ], + [ + "not ", + "all " + ], + [ + "In", + "v" + ], + [ + "and ", + "each " + ], + [ + "and ", + "only if the " + ], + [ + ".sol", + "\\n\\n" + ], + [ + "set", + "ExtraData" + ], + [ + "total", + "Borrow" + ], + [ + ");\\n", + "\\n if (" + ], + [ + "s the ", + "ownership " + ], + [ + "bytes32", + "[](" + ], + [ + ") external ", + "onlyOwner" + ], + [ + "cur", + "r " + ], + [ + ") public ", + "view " + ], + [ + ") public ", + "returns (bool) {\\n " + ], + [ + ") public ", + "onlyOwner {\\n require(" + ], + [ + "contract ", + "was successful, and " + ], + [ + "check", + "s " + ], + [ + "msg.sender", + " " + ], + [ + "current", + "(" + ], + [ + "current", + "TokenId" + ], + [ + "Balanc", + "es[msg.sender" + ], + [ + "ail", + "ing " + ], + [ + "sign", + "al " + ], + [ + "totalSupply", + "() public view returns (" + ], + [ + "Returns the ", + "next " + ], + [ + ", \\\"", + "MerkleProof: invalid multiproof" + ], + [ + "target", + "ed by the call" + ], + [ + " ", + " " + ], + [ + "`to", + "TokenId" + ], + [ + "Contract", + "." + ], + [ + "Balance", + "\"" + ], + [ + "0.8", + "/" + ], + [ + "Wallet", + "Updated" + ], + [ + "/contracts/", + "contracts/" + ], + [ + ".\\n */\\n function _", + "nextTokenId" + ], + [ + ".\\n */\\n function _", + "initialize" + ], + [ + "decimals", + "} to " + ], + [ + "hash", + "ing and " + ], + [ + "transferFrom", + ".selector, " + ], + [ + "(_", + "packedOwnerships[" + ], + [ + "\\n // ", + "in" + ], + [ + "amount ", + "overflow" + ], + [ + ") internal virtual ", + "returns (uint256 " + ], + [ + "AT", + "ED" + ], + [ + "0 ", + "&& _" + ], + [ + "in the ", + "range " + ], + [ + "using ", + "abi.encode " + ], + [ + "+= ", + "amount" + ], + [ + ") public virtual ", + "returns (bool) {\\r\\n " + ], + [ + ");\\n ", + "require(" + ], + [ + ");\\n ", + "emit " + ], + [ + "support", + "s " + ], + [ + "call ", + "data (" + ], + [ + "33", + "3" + ], + [ + "() external view returns (", + "uint);\\n\\n function " + ], + [ + "At", + "Tick" + ], + [ + "ApprovalForAll", + "} event.\\n */\\n function _" + ], + [ + " and ", + "the return " + ], + [ + "proof", + "Po" + ], + [ + "++", + "_packedAddressData[to]; // Updates: `balance += 1`." + ], + [ + "es[", + "_from" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Returns the ", + "next token ID to be minted" + ], + [ + "; // ", + "and not " + ], + [ + "given ", + "by" + ], + [ + "De", + "pend" + ], + [ + "()", + ");\\n " + ], + [ + ";\\n }\\n ", + "_balances[to] += " + ], + [ + "////////////////////////////////", + "////////////////////////////////" + ], + [ + ");\\n _", + ";\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual " + ], + [ + "(owner, ", + "operator, approved);\\n }\\n\\n /**\\n * @dev " + ], + [ + ") / ", + "10000" + ], + [ + "ter ", + "for the " + ], + [ + "s\\n * ", + "with a standardized message including the required role" + ], + [ + "\\n // ", + "otherwise " + ], + [ + "call to ", + "smart-" + ], + [ + "minted ", + "with " + ], + [ + "packedOwnership", + "Of(uint256 tokenId" + ], + [ + "];\\n ", + "} else {\\n return " + ], + [ + "either ", + "by bubbl" + ], + [ + "bot", + "s[" + ], + [ + "36", + "5" + ], + [ + "0000000000000000", + "00" + ], + [ + "operation", + "s that " + ], + [ + "revert reason ", + "or " + ], + [ + "disable", + "Initializer" + ], + [ + "/// @", + "author: " + ], + [ + "_currentIndex", + ";\\n }\\n\\n /**\\n * @dev Returns the " + ], + [ + "revert(", + "bytes memory returndata" + ], + [ + " ", + "// " + ], + [ + "collection", + " is " + ], + [ + ")\\n ", + "if (!" + ], + [ + ")\\n ", + "revert(add(32, returndata), returndata_size" + ], + [ + ";\\r\\n ", + "uint256 private " + ], + [ + "super.", + "_transfer(from, to, amount" + ], + [ + "(address to, uint256 ", + "value" + ], + [ + "extraData", + "(\\n address from,\\n address to,\\n " + ], + [ + "prevOwnership", + ".startTimestamp" + ], + [ + ") {\\n _", + "paused = false" + ], + [ + "Calling ", + "this function " + ], + [ + "`owner` ", + "tokens" + ], + [ + ".sol\\\";\\nimport \\\"../../", + "math/SafeMath" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0", + ";\\n\\n/**\\n * @title " + ], + [ + " == 0", + "; // and not " + ], + [ + "Desired", + ",\\n uint amountTokenMin,\\n uint amountETHMin,\\n address to,\\n uint deadline" + ], + [ + ");\\n }\\n }\\n\\n /**\\n * @dev ", + "Tool to " + ], + [ + "run", + "n" + ], + [ + "gh", + "t = " + ], + [ + "{\\n // ", + "Look for revert reason and bubble it up if present" + ], + [ + ".\\n */\\ninterface ", + "ERC721A__IERC721Receiver" + ], + [ + ".\\n * @param ", + "data The " + ], + [ + "ever ", + "change" + ], + [ + "default ", + "one of " + ], + [ + ";\\n uint256 internal constant ", + "ERC20" + ], + [ + "cost", + "s" + ], + [ + "`).\\n *\\n * ", + "If you are writing GSN compatible contracts, you need to override this function" + ], + [ + "setup", + "Decimals" + ], + [ + "assum", + "e " + ], + [ + " is not ", + "a contract" + ], + [ + "Ratio", + "AtTick" + ], + [ + "\\n\\t * ", + "@dev " + ], + [ + ");\\n }\\n\\n /**\\n * @notice ", + "Update the " + ], + [ + "Stake", + "." + ], + [ + "\\n *\\n * _Available since v4.", + "1._" + ], + [ + "root ", + "is " + ], + [ + "Atomically ", + "increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n " + ], + [ + ".\\n // ", + "We will need " + ], + [ + ") private view returns (", + "uint256) {\\n uint256 " + ], + [ + "`.\\n */\\n function _", + "unpackedOwnership" + ], + [ + "Slot ", + ":= " + ], + [ + ")\\n // ", + "Update the free memory pointer to allocate" + ], + [ + "KKKKKKKK", + "KKKK" + ], + [ + "_remove", + "Minter" + ], + [ + ") internal view returns (bytes memory", + ") {\\n if (success" + ], + [ + "));\\n ", + "ownership.startTimestamp = uint64(" + ], + [ + "revert (", + "either by bubbl" + ], + [ + "bi", + "toshis" + ], + [ + "exempt", + "From" + ], + [ + "exceed ", + "the " + ], + [ + "PERMIT_TYPEHASH", + "() external pure returns (bytes32" + ], + [ + "``owner``'s ", + "signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature " + ], + [ + "execut", + "e " + ], + [ + "address) {\\n return msg.sender", + ";\\n }\\n\\n /**\\n * @dev " + ], + [ + "mapping(address => uint256) private ", + "_packedAddressData" + ], + [ + ");\\n\\n if (", + "address(uint160(prevOwnershipPacked)) != " + ], + [ + "it to ", + "zero" + ], + [ + "Request", + "ed" + ], + [ + "`\\n * ", + "(" + ], + [ + ");\\n\\n ", + "/**\\n * @notice " + ], + [ + "\\n * @param _", + "value " + ], + [ + ") internal virtual {\\n uint256 ", + "prevOwnershipPacked = _packedOwnershipOf(tokenId" + ], + [ + "inv", + "est" + ], + [ + "STA", + "K" + ], + [ + ") private pure returns (", + "TokenOwnership memory ownership" + ], + [ + "\\n virtual\\n override", + "\\n returns (" + ], + [ + " == 0) {\\n ", + "// only " + ], + [ + "{decimals} ", + "to a value " + ], + [ + "OOOOOOOO", + "OOOO" + ], + [ + ");\\n}\\n\\n", + "contract " + ], + [ + "ing\\n * the ", + "revert reason or " + ], + [ + "Get", + "ter for the " + ], + [ + "was successful", + " and the return " + ], + [ + "low level ", + "call to smart-" + ], + [ + ";\\n\\n // The bit position of `", + "aux" + ], + [ + ";\\n\\n // The bit position of `", + "numberBurned" + ], + [ + "override returns (bool) {\\n return interfaceId == type(", + "IAccessControl" + ], + [ + "that it ", + "was a " + ], + [ + "BITPOS_START_TIMESTAMP", + ");\\n ownership.burned = " + ], + [ + "`operator` to ", + "operate on " + ], + [ + "work ", + "incorrectly " + ], + [ + "ERC721A__", + "IERC721Receiver(to).onERC721Received" + ], + [ + ",\\n address[] calldata path", + ",\\n address to,\\n uint256 deadline" + ], + [ + "let returndata_size := mload(returndata", + ")\\n revert(add(32, returndata), returndata_size" + ], + [ + "numCheckpoint", + "s[" + ], + [ + "in case of ", + "unsuccessful " + ], + [ + "Sets ", + "{decimals} to a value " + ], + [ + "}\\n return ", + "returndata;\\n } else {" + ], + [ + ",\\n uint amountToken", + "Desired,\\n uint amountTokenMin,\\n uint amountETHMin,\\n address to,\\n uint deadline" + ], + [ + "encoded ", + "using abi.encode " + ], + [ + "empty", + "\\n // otherwise " + ], + [ + "packed = _", + "packedAddressData[owner" + ], + [ + "proxy/", + "Proxy" + ], + [ + "_ownerships[", + "curr]" + ], + [ + ",\\r\\n address to,\\r\\n uint256 ", + "deadline" + ], + [ + "isOperator", + "For" + ], + [ + "compute the ", + "next " + ], + [ + "BITPOS_AUX", + ");\\n }\\n\\n /**\\n * " + ], + [ + "know ", + "that it was a " + ], + [ + "index out of bound", + "s\"" + ], + [ + "until ", + "trading is " + ], + [ + "verify that a ", + "low level call to smart-" + ], + [ + "// solhint-disable-next-line avoid-low-level-call", + "s, avoid-call-value" + ], + [ + "data is ", + "empty\\n // otherwise " + ], + [ + "index]", + ");\\n }\\n\\n /**\\n * @dev " + ], + [ + ".\\n ", + "//\\n // " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Tool to ", + "verify that a low level call to smart-" + ], + [ + "verifyCallResultFromTarget", + "(\\n address target,\\n bool " + ], + [ + "starts ", + "with the " + ], + [ + "] = approved;\\n emit ApprovalForAll", + "(owner, operator, approved);\\n }\\n\\n /**\\n * @dev " + ], + [ + ".sol\\\";\\r\\n\\r\\n", + "contract " + ], + [ + ".\\n * To ", + "change the starting token ID" + ], + [ + "onlyInitializ", + "ing" + ], + [ + "0 ? string(abi.encodePacked(baseURI, ", + "_toString(tokenId))) : " + ], + [ + "packed = _packedOwnerships[", + "--" + ], + [ + "reach", + "ed" + ], + [ + "all of ", + "`owner` tokens" + ], + [ + "will not ", + "expect" + ], + [ + "prettier-ignore", + "\\n for {" + ], + [ + "\"erc721a/contracts/", + "ERC721A.sol\"" + ], + [ + ".\\n */\\n function _total", + "Burned(" + ], + [ + "WE", + "IGH" + ], + [ + "This function should only be called from the ", + "constructor. " + ], + [ + "join ", + "or " + ], + [ + ".\\n *\\n * ", + "Note: " + ], + [ + "`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash", + "(bytes memory s" + ], + [ + "mer", + "ging " + ], + [ + "][operator] = approved;\\n emit ApprovalForAll", + "(_msgSenderERC721A(), " + ], + [ + "branch", + "es" + ], + [ + "starting token ID", + ".\\n * To change the starting token ID" + ], + [ + "amond", + "Cut" + ], + [ + "paused(), \\\"Pausable: ", + "not paused" + ], + [ + "expon", + "ent" + ], + [ + ") - 1;\\n\\n // The bit position of `", + "startTimestamp" + ], + [ + ") - 1;\\n\\n // The bit position of `", + "numberMinted" + ], + [ + ";\\n\\n // The bit mask", + " of the `burned` " + ], + [ + ") public virtual override onlyRole(getRoleAdmin(role)) {\\n _", + "revokeRole(role, account);\\n }\\n\\n /**\\n * @dev " + ], + [ + ") public virtual override onlyRole(getRoleAdmin(role)) {\\n _", + "grantRole(role, account);\\n }\\n\\n /**\\n * @dev " + ], + [ + "ju", + "ice-" + ], + [ + ";\\n\\n // Mask of all 256 bits ", + "in packed address data except the 64 bits for `aux" + ], + [ + "of `tokenId`.\\n */\\n function _", + "packedOwnershipOf(uint256 tokenId" + ], + [ + ") {\\n (bool success, bytes memory returndata) = target", + ".staticcall" + ], + [ + "getApproved(tokenId) == spender", + " || " + ], + [ + "depos", + "its" + ], + [ + "token contracts ", + "will not expect" + ], + [ + "was not ", + "a contract" + ], + [ + "sire", + "Id" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub", + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n return " + ], + [ + "if (to.isContract()) {\\n ", + "try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (" + ], + [ + "JSON ", + "RPC " + ], + [ + "];\\n uint256 ", + "aux" + ], + [ + "interact with ", + "token contracts will not expect" + ], + [ + "onlyTeam", + "OrOwner" + ], + [ + "amount + ", + "balanceOf(to) <= " + ], + [ + "```\\n * contract ", + "Example {\\n * // Add the library methods\\n * using " + ], + [ + "\\n ) external virtual ", + "override " + ], + [ + "FEE_D", + "ENOMINATOR" + ], + [ + "at `index`.\\n */\\n function ", + "_ownershipAt(uint256 index" + ], + [ + "address receiver, uint256 royaltyAmount", + ");\\n}\\n\"" + ], + [ + "uint256) {\\n // Counter underflow is impossible as _burnCounter cannot be incremented\\n // more than ", + "`_currentIndex - _startTokenId()` " + ], + [ + "does not decrement,\\n // and it is initialized to ", + "`" + ], + [ + ", please override this function.\\n */\\n function _startTokenId() internal view virtual returns (uint256) {\\n return 0", + ";\\n }\\n\\n /**\\n * @dev Returns the next token ID to be minted" + ], + [ + "_operatorApprovals[owner][operator", + "] = approved;\\n emit ApprovalForAll(owner, operator, approved);\\n }\\n\\n /**\\n * @dev " + ], + [ + "tokens,\\n * given ", + "``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature " + ], + [ + ");\\n\\n address from", + " = address(uint160(prevOwnershipPacked" + ], + [ + "// If ", + "within bound" + ], + [ + "balance query for the zero address", + "\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: " + ], + [ + "gam", + "es" + ], + [ + "\"@openzeppelin/contracts/access/AccessControl", + ".sol\"" + ], + [ + "we already ", + "know that it was a " + ], + [ + "Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on ", + "{IERC20-approve}, the " + ], + [ + ".\\n mstore(0x40, ", + "m" + ], + [ + "MinimalSwapInfo", + "Pool" + ], + [ + "other than the ", + "default one of " + ], + [ + "PROV", + "ID" + ], + [ + "maj", + "or " + ], + [ + ", and may ", + "work incorrectly " + ], + [ + "APPROVAL", + " OPERATIONS\\n // =============================================================\\n\\n /**\\n * @dev " + ], + [ + "call or ", + "if target " + ], + [ + "\\n */\\n modifier only", + "Role(bytes32 role) {\\n _check" + ], + [ + "Equivalent to `_burn(tokenId, false)`.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n _burn(tokenId, false);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId, bool approvalCheck", + ") internal virtual {\\n uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId" + ], + [ + "The easiest way to bubble the revert reason is using memory via assembly", + "\\n /// @solidity memory-safe-assembly\\n assembly {\\n " + ], + [ + "sqr", + "t " + ], + [ + "token The token ", + "targeted by the call" + ], + [ + ")\\n // Move the pointer ", + "32 bytes leftwards to make room for the length.\\n " + ], + [ + "(sender, recipient, amount);\\n\\n uint256 senderBalance = _balances[sender];\\n require(", + "senderBalance " + ], + [ + "roles[role].members[account", + "];\\n }\\n\\n /**\\n * @dev " + ], + [ + "_packedOwnerships[index", + "] == 0) {\\n " + ], + [ + "\\n */\\n function _check", + "Role(bytes32 role, address account" + ], + [ + "Returns an Ethereum Signed Message, created from `s", + "`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash(bytes memory s" + ], + [ + "(from, to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits a {Approval", + "} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721.ownerOf(tokenId), to, tokenId" + ], + [ + "(uint256 packed", + ") private pure returns (TokenOwnership memory ownership" + ], + [ + "applications that ", + "interact with token contracts will not expect" + ], + [ + ", 1)\\n // ", + "Write the character to the pointer" + ], + [ + "Previou", + "s " + ], + [ + "from `packed", + "`.\\n */\\n function _unpackedOwnership" + ], + [ + "total number of tokens burned", + ".\\n */\\n function _totalBurned(" + ], + [ + "BITPOS_START_TIMESTAMP = 160", + ";\\n\\n // The bit mask of the `burned` " + ], + [ + "BITPOS_NUMBER_MINTED = 64", + ";\\n\\n // The bit position of `numberBurned" + ], + [ + "BITPOS_NUMBER_BURNED = 128", + ";\\n\\n // The bit position of `aux" + ], + [ + "BITPOS_AUX = 192", + ";\\n\\n // Mask of all 256 bits in packed address data except the 64 bits for `aux" + ], + [ + "BITPOS_NEXT_INITIALIZED = 225", + ";\\n\\n // The bit mask" + ], + [ + "packed ownership data ", + "of `tokenId`.\\n */\\n function _packedOwnershipOf(uint256 tokenId" + ], + [ + "_operatorApprovals[_msgSenderERC721A()", + "][operator] = approved;\\n emit ApprovalForAll(_msgSenderERC721A(), " + ], + [ + "_AUX_COMPLEMENT = (1 << 192", + ") - 1;\\n\\n // The bit position of `startTimestamp" + ], + [ + "interfaceId == 0x80ac58cd || // ERC165 interface ID for ", + "ERC721" + ], + [ + "_packedOwnerships[index] = _packedOwnershipOf(index", + ");\\n }\\n }\\n\\n " + ], + [ + "Contract module which allows children to implement an emergency stop\\n * mechanism that can be triggered by an authorized account.\\n *\\n * This module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\\n * the functions of your contract. Note that they will not be pausable by\\n * simply including this module, only once the modifiers are put in place.\\n */\\nabstract contract ", + "Pausable is Context {\\n /**\\n * @dev Emitted when the pause is triggered by `account`.\\n */\\n event Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by `account`.\\n */\\n event Unpaused(address account);\\n\\n bool private _paused;\\n\\n /**\\n * @dev Initializes the contract in unpaused state" + ], + [ + "message sender (defaults to `msg.sender", + "`).\\n *\\n * If you are writing GSN compatible contracts, you need to override this function" + ], + [ + "ownership.addr = address(uint160(packed", + "));\\n ownership.startTimestamp = uint64(" + ], + [ + "BITMASK_ADDRESS_DATA_ENTRY = (1 << 64", + ") - 1;\\n\\n // The bit position of `numberMinted" + ], + [ + "Initializes the ownership slot minted at `index` for efficiency purposes", + ".\\n */\\n function _initialize" + ], + [ + "enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ", + "```\\n * contract Example {\\n * // Add the library methods\\n * using " + ], + [ + "typed ", + "structured " + ], + [ + "over ``owner``'s ", + "tokens,\\n * given ``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature " + ], + [ + ") {\\n if (returndata.length", + " == 0) {\\n // only " + ], + [ + ".\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator\\n ) internal pure returns (uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0))\\n prod0 := mul(x, y)\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1 == 0) {\\n return prod0 / denominator;\\n }\\n\\n // Make sure the result is less than 2^256. Also prevents denominator == 0.\\n require(denominator > prod1", + ");\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator)\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder)\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function.\\n uint256 twos = denominator & (~denominator + 1);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1)\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step.\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator,\\n Rounding rounding\\n " + ], + [ + "Revert with a standard message if `account` is missing `role", + "`.\\n *\\n * The " + ], + [ + "Modifier that checks that an account has a specific role. Revert", + "s\\n * with a standardized message including the required role" + ], + [ + "on the return value: the return value is optional (but if data is returned, it must not be false", + ")." + ], + [ + "or one ", + "of its " + ], + [ + ".\\n */\\n function _msgSenderERC721A() internal view virtual returns (", + "address) {\\n return msg.sender;\\n }\\n\\n /**\\n * @dev " + ], + [ + "if the call ", + "was successful and the return " + ], + [ + "contract was successful, and ", + "revert (either by bubbl" + ], + [ + "decimals} to ", + "ever change" + ], + [ + "hashing and ", + "sign" + ], + [ + "transferFrom.selector, ", + "from, to, value" + ], + [ + "call data (", + "encoded using abi.encode " + ], + [ + "ApprovalForAll} event.\\n */\\n function _", + "setApprovalForAll" + ], + [ + ");\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual ", + "override returns (bool) {\\n return interfaceId == type(IAccessControl" + ], + [ + "extraData(\\n address from,\\n address to,\\n ", + "uint24 previousExtraData" + ], + [ + " == 0; // and not ", + "burned." + ], + [ + ");\\n }\\n }\\n\\n /**\\n * @dev Tool to ", + "verify that a " + ], + [ + "{\\n // Look for revert reason and bubble it up if present", + "\\n if (" + ], + [ + "\\n *\\n * _Available since v4.1._", + "\\n */\\n modifier onlyRole(bytes32 role) {\\n _check" + ], + [ + ") internal view returns (bytes memory) {\\n if (success", + ") {\\n if (returndata.length == 0) {\\n // only " + ], + [ + "`operator` to operate on ", + "all of `owner` tokens" + ], + [ + "let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size", + ")\\n }\\n } else {\\n " + ], + [ + "in case of unsuccessful ", + "call or if target " + ], + [ + "Sets {decimals} to a value ", + "other than the default one of " + ], + [ + "BITPOS_AUX);\\n }\\n\\n /**\\n * ", + "Sets the " + ], + [ + "data is empty\\n // otherwise ", + "we already know that it was a " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-", + "contract was successful, and revert (either by bubbl" + ], + [ + "verifyCallResultFromTarget(\\n address target,\\n bool ", + "success" + ], + [ + "0 ? string(abi.encodePacked(baseURI, _toString(tokenId))) : ", + "''" + ], + [ + "This function should only be called from the constructor. ", + "Most" + ], + [ + "juice-", + "contracts-" + ], + [ + "amount + balanceOf(to) <= ", + "maxWallet" + ], + [ + ", please override this function.\\n */\\n function _startTokenId() internal view virtual returns (uint256) {\\n return 0;\\n }\\n\\n /**\\n * @dev Returns the next token ID to be minted", + ".\\n */\\n function _nextTokenId" + ], + [ + "balance query for the zero address\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _owners[tokenId];\\n require(owner != address(0), \\\"ERC721: ", + "owner query for nonexistent token\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n require(_exists(tokenId), \\\"ERC721Metadata: URI query for nonexistent token\\\");\\n\\n " + ], + [ + ", and may work incorrectly ", + "if it does" + ], + [ + "Equivalent to `_burn(tokenId, false)`.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n _burn(tokenId, false);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId, bool approvalCheck) internal virtual {\\n uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId", + ");\\n\\n address from = address(uint160(prevOwnershipPacked" + ], + [ + "The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n ", + "let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n " + ], + [ + "Returns an Ethereum Signed Message, created from `s`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash(bytes memory s", + ") internal pure returns (bytes32) {\\n return " + ], + [ + "message sender (defaults to `msg.sender`).\\n *\\n * If you are writing GSN compatible contracts, you need to override this function", + ".\\n */\\n function _msgSenderERC721A() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n /**\\n * @dev " + ], + [ + "Initializes the ownership slot minted at `index` for efficiency purposes.\\n */\\n function _initialize", + "OwnershipAt(uint256 index" + ], + [ + "over ``owner``'s tokens,\\n * given ``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature ", + "for {permit}, as " + ], + [ + "Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role", + ".\\n *\\n * The " + ], + [ + "if the call was successful and the return ", + "data is empty\\n // otherwise we already know that it was a " + ], + [ + "decimals} to ever change", + ", and may work incorrectly if it does" + ], + [ + "call data (encoded using abi.encode ", + "or one of its " + ], + [ + "in case of unsuccessful call or if target ", + "was not a contract" + ], + [ + "Sets {decimals} to a value other than the default one of ", + "18" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbl", + "ing\\n * the revert reason or " + ], + [ + "if the call was successful and the return data is empty\\n // otherwise we already know that it was a ", + "contract" + ], + [ + " ", + "S" + ], + [ + " ", + "let temp := " + ], + [ + "\"", + "convex" + ], + [ + "'", + "swap and pop" + ], + [ + "'", + ").\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex" + ], + [ + "(", + "name" + ], + [ + "(", + "bytes32[] memory proof" + ], + [ + ",", + "\\n * " + ], + [ + "-", + "= _" + ], + [ + "-", + "platform" + ], + [ + "/", + " " + ], + [ + "0", + "\\n // " + ], + [ + "1", + "d" + ], + [ + "4", + " " + ], + [ + ";", + "` " + ], + [ + ";", + "\\n // " + ], + [ + "B", + " " + ], + [ + "F", + "8" + ], + [ + "I", + "VER" + ], + [ + "L", + "at" + ], + [ + "L", + "and" + ], + [ + "M", + "e" + ], + [ + "N", + "ext " + ], + [ + "Q", + "R" + ], + [ + "S", + "\"" + ], + [ + "T", + "PL" + ], + [ + "[", + " " + ], + [ + "_", + "signer" + ], + [ + "_", + "ZERO_ADDRESS" + ], + [ + "`", + "\\n * @param " + ], + [ + "`", + "\\n mapping(uint256 => uint256) private " + ], + [ + "a", + "C" + ], + [ + "a", + ",\\r\\n uint256 " + ], + [ + "e", + "op" + ], + [ + "f", + "ilter" + ], + [ + "l", + "ication " + ], + [ + "}", + "\\n // " + ], + [ + "\\n", + "*" + ], + [ + "\\n", + "pragma solidity 0.8." + ], + [ + "\\n ", + " " + ], + [ + "on", + "e {" + ], + [ + "res", + "." + ], + [ + ", ", + "address(this), " + ], + [ + ", ", + "eq(" + ], + [ + ") ", + "20" + ], + [ + "address", + "To" + ], + [ + "address", + "Data." + ], + [ + "the ", + "ID of the " + ], + [ + "\\\"", + " to the " + ], + [ + "is ", + "owed and to whom" + ], + [ + "as", + "c" + ], + [ + "from", + "` cannot be the zero address.\\n * - `" + ], + [ + "of ", + "this " + ], + [ + ") {", + "\\n\\t\\t" + ], + [ + "er ", + "will " + ], + [ + "transfer", + "ing.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `" + ], + [ + "an ", + "overflow" + ], + [ + "- ", + "An " + ], + [ + "Transfer", + "able" + ], + [ + "return ", + "no " + ], + [ + " = ", + "30" + ], + [ + ",\\n ", + "bytes calldata " + ], + [ + "In", + ",\\n uint amount" + ], + [ + "ERC721", + "(\\\"" + ], + [ + "and ", + "instead " + ], + [ + "Amount", + "To" + ], + [ + "get", + "TotalFee" + ], + [ + "get", + "AddressSlot" + ], + [ + " to ", + "your contract" + ], + [ + "), ", + "Errors." + ], + [ + "Cont", + "roll" + ], + [ + "Address", + "(address _" + ], + [ + "bytes32", + "(0" + ], + [ + "true", + "`.\\n // - `nextInitialized` to `" + ], + [ + "be", + "en" + ], + [ + "max", + "Mint" + ], + [ + "max", + "MintAmountPerTx" + ], + [ + "token ", + "URI" + ], + [ + "min", + "HoldingAmount" + ], + [ + "the", + "\\n" + ], + [ + "== ", + "0 || " + ], + [ + "current", + "Value" + ], + [ + "cre", + "ation.\\n *\\n * " + ], + [ + "burn", + "ing.\\n // - `burned` to `" + ], + [ + ");\\n\\n ", + "require(\\n " + ], + [ + " is ", + "IERC721A" + ], + [ + " is ", + "very " + ], + [ + "Mint", + "s " + ], + [ + "(\\n ", + "uint256[] memory balances" + ], + [ + ", \\\"", + "Exceeds the " + ], + [ + "swap", + "Times" + ], + [ + "ill", + "ary data for `owner`. (e.g. number of whitelist mint slots used" + ], + [ + "Li", + "q" + ], + [ + "bytes32 ", + "previousAdmin" + ], + [ + " b", + "ack" + ], + [ + "event ", + "for " + ], + [ + "] = ", + "block.number" + ], + [ + "\\\");\\n ", + "_operatorApprovals[owner][operator] = approved;\\n emit ApprovalForAll(owner, operator, approved);\\n }\\n\\n /**\\n * @dev " + ], + [ + "`.", + "\\n function " + ], + [ + "noti", + "ce " + ], + [ + "false", + "). " + ], + [ + "Math", + ": " + ], + [ + "decimals", + "() external pure returns (" + ], + [ + "uint8", + "((" + ], + [ + "Un", + "pause" + ], + [ + "ult", + "ane" + ], + [ + "\\n * @dev ", + "Wrappers " + ], + [ + "ID", + " for " + ], + [ + "start", + ",\\n uint256 " + ], + [ + " != ", + "address(0), " + ], + [ + ".\\n * ", + "For " + ], + [ + "= _", + "hashTypedDataV4(" + ], + [ + "uniswapV2Router", + ".swapExactTokensForETHSupportingFeeOnTransferTokens" + ], + [ + "unchecked ", + "{\\n " + ], + [ + "UniswapV2", + "Library" + ], + [ + "lea", + "rn" + ], + [ + "current ", + "computed hash" + ], + [ + "current ", + "element of the " + ], + [ + "\"@openzeppelin/contracts/", + "access/IAccessControl" + ], + [ + "(from, ", + "address(this), " + ], + [ + "vo", + "ter" + ], + [ + "use ", + "this library " + ], + [ + "BIT", + "_LENGTH" + ], + [ + ";\\r\\n", + " " + ], + [ + "), \\\"", + "SafeERC20: " + ], + [ + "Mo", + "nth" + ], + [ + "s are ", + "done " + ], + [ + "update", + "CodeHash" + ], + [ + "last ", + "owner.\\n // - `startTimestamp` to the timestamp of " + ], + [ + "++", + "] = " + ], + [ + "Check", + " the " + ], + [ + "down", + "scal" + ], + [ + "multi", + "sig" + ], + [ + ".\\n ", + "interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata." + ], + [ + ".\\n ", + "interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721" + ], + [ + "Pack", + "s " + ], + [ + "tokensFor", + "Marketing " + ], + [ + "Byt", + "es " + ], + [ + "Byt", + "ecode" + ], + [ + "To ", + "use this library " + ], + [ + "Allow", + "s " + ], + [ + "valid", + "ator" + ], + [ + "ST", + "_" + ], + [ + "`. ", + "For " + ], + [ + "\\n //", + " - " + ], + [ + "Info", + "(" + ], + [ + "Info", + "[" + ], + [ + "Base", + "Token" + ], + [ + " = _", + "currentIndex" + ], + [ + "transferred ", + "from `from` to `to" + ], + [ + "Par", + "tic" + ], + [ + "ERC20 ", + "operations that " + ], + [ + "\\n\\n /**\\n * @dev ", + "Returns the " + ], + [ + "_check", + "Role" + ], + [ + "also ", + "supported, " + ], + [ + "36", + "00" + ], + [ + "low-level ", + "call failed" + ], + [ + "|| ", + "msg.sender == " + ], + [ + "2**", + "64." + ], + [ + "Lock", + "up" + ], + [ + "if (!", + "isApprovedOrOwner" + ], + [ + "if (!", + "hasRole(role, account)) {\\n " + ], + [ + "lp", + "WithdrawRequest" + ], + [ + ", the ", + "last " + ], + [ + "_currentIndex", + " != end" + ], + [ + ".sol\\\";\\nimport \\\"./", + "I" + ], + [ + "Ar", + "g" + ], + [ + ", but ", + "also " + ], + [ + "next ", + "owner.\\n // - `startTimestamp` to the timestamp of " + ], + [ + "Transfers ", + "`tokenId` from `from` to `to`" + ], + [ + "standard ", + "for " + ], + [ + "address) {\\n return ", + "address(uint160(_packedOwnershipOf(tokenId" + ], + [ + "map", + ", " + ], + [ + "10**", + "18" + ], + [ + "bel", + "ow" + ], + [ + "swapTokensForEth", + "(uint256 tokenAmount" + ], + [ + ") {\\n return ", + "_" + ], + [ + "safe ", + "operations " + ], + [ + "values ", + "on a " + ], + [ + "off", + "set, " + ], + [ + "this contract ", + "does not " + ], + [ + "aux", + "illary data for `owner`. (e.g. number of whitelist mint slots used" + ], + [ + "tick", + " of the " + ], + [ + "consum", + "ing and " + ], + [ + "array ", + "of `" + ], + [ + "_IN", + "VARIANT" + ], + [ + "process", + ", the last " + ], + [ + "add ", + "a `" + ], + [ + "Orac", + "le " + ], + [ + "around ", + "ERC20 operations that " + ], + [ + "\\n ) external returns (", + "uint[] memory amounts);\\n function " + ], + [ + "\\n ) external returns (", + "uint amountToken, uint amountETH" + ], + [ + "\\n ) external returns (", + "uint amountETH" + ], + [ + ".\\n // ", + "This is equivalent to `packed -= 1; packed += 1" + ], + [ + ";\\n _", + "decimals = 18" + ], + [ + "utils/Context.sol\\\";\\n\\n/**\\n * @dev ", + "Extension of {ERC20} that allows token holders to destroy both their own\\n * tokens and those that they have an allowance for, in a way that can be\\n * recognized off-chain (via event analysis).\\n */\\nabstract contract ERC20Burnable is Context, ERC20 {\\n /**\\n * @dev Destroys `amount` tokens from the caller.\\n *\\n * See {ERC20-_burn}.\\n */\\n function burn(uint256 amount) public virtual {\\n _burn(_msgSender(), amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, deducting from the caller's\\n * allowance.\\n *\\n * See {ERC20-_burn} and {ERC20-allowance}.\\n *\\n * Requirements:\\n *\\n * - the caller must have allowance for ``accounts``'s tokens of at least\\n * `amount`.\\n */\\n function burnFrom(address account, uint256 amount) public virtual " + ], + [ + "userData", + "." + ], + [ + "Bas", + "isPoint" + ], + [ + "returns ", + "false). " + ], + [ + ";\\n }", + " " + ], + [ + "\\n /// @return ", + "amount" + ], + [ + "as `", + "token.safeTransfer(" + ], + [ + "Asset", + "s" + ], + [ + "ensure", + "InputLength" + ], + [ + ";\\n\\n // ", + "Updates:\\n // - `address` to the " + ], + [ + "separ", + "ate " + ], + [ + "AdminRole", + ", adminRole" + ], + [ + "mload(add(", + "table" + ], + [ + "\\n\\n // ", + "Updates:\\n // - `address` to the " + ], + [ + "...", + ")`, " + ], + [ + "].add(", + "amount" + ], + [ + "inv", + "ol" + ], + [ + "Statu", + "s." + ], + [ + "market", + ".total" + ], + [ + "hand", + "le " + ], + [ + "unrealis", + "tic" + ], + [ + "`.\\n // - `", + "numberBurned += 1" + ], + [ + "_baseURI", + "() internal view virtual override returns (" + ], + [ + "you can ", + "add a `" + ], + [ + "| |", + "\\n * " + ], + [ + "_CACHED", + "_THIS" + ], + [ + "on failure", + ") are " + ], + [ + "reser", + "ves" + ], + [ + "DefaultRoyalty", + "(address " + ], + [ + "\"// SPDX-License-Identifier: GPL-3.0-or-later", + "\\npragma solidity 0.8.17" + ], + [ + "ConsecutiveTransfer", + "} event" + ], + [ + ");\\n }\\n }\\n\\n /**\\n * @dev Returns the ", + "admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role" + ], + [ + "serv", + "ice" + ], + [ + "for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator", + ", bool approved" + ], + [ + ", \\\"ERC721: ", + "approve to caller" + ], + [ + "from != ", + "owner() " + ], + [ + "if (a ", + ">= " + ], + [ + "spendAllowance(", + "account" + ], + [ + "_init_unchain", + "ed" + ], + [ + "BBBBBBBBBBBBBBBB", + "BBBBBBBBBBBBBBBB" + ], + [ + "verification", + " of " + ], + [ + ".\\n unchecked {\\n // ", + "We can directly increment and decrement the balances" + ], + [ + "overridden ", + "by the " + ], + [ + " {\\n function ", + "onERC721Received(\\n address operator,\\n address from,\\n uint256 tokenId,\\n bytes calldata data\\n ) external returns (bytes4);\\n}\\n\\n" + ], + [ + ",uint256 nonce,uint256 ", + "expiry" + ], + [ + "charact", + "er is " + ], + [ + "MUST ", + "NOT " + ], + [ + "Limit ", + "= " + ], + [ + "name ", + "= _" + ], + [ + "statement", + " to your contract" + ], + [ + "KO", + "DA" + ], + [ + "to.code.length", + " != 0) {\\n " + ], + [ + "`.\\n //\\n // We can directly ", + "decrement the balance, and increment the number burned" + ], + [ + "hashPair", + "(computedHash, " + ], + [ + "` function", + "s. " + ], + [ + "token/ERC20/extensions/ERC20Burnable", + ".sol\"" + ], + [ + ".\\n unchecked {\\n // Updates:\\n // - `balance ", + "-= 1" + ], + [ + "TransferHelper", + ".safeTransfer" + ], + [ + "sent to ", + "the " + ], + [ + "chain id ", + "to " + ], + [ + "efficient ", + "minting " + ], + [ + ".\\n //\\n // ", + "Bits Layout:\\n // - [0.." + ], + [ + "cal", + "endar" + ], + [ + "throw ", + "on failure " + ], + [ + "throw ", + "on failure) are " + ], + [ + "branch", + "less " + ], + [ + "(_packedOwnershipOf(tokenId", + ")" + ], + [ + "value (", + "and instead " + ], + [ + "RARELOOKS", + "R" + ], + [ + "(address, ", + "address" + ], + [ + "uint256) private _balances", + ";\\n\\n mapping (address => mapping (address => uint256" + ], + [ + ", uint256 index) internal view returns (", + "address) {\\n return " + ], + [ + "_startTokenId();\\n }\\n }\\n\\n /**\\n * @dev Returns the ", + "total amount of tokens minted in the contract.\\n */\\n function _totalMinted(" + ], + [ + "_startTokenId();\\n }\\n }\\n\\n /**\\n * @dev Returns the ", + "total number of tokens burned.\\n */\\n function _totalBurned(" + ], + [ + "bytes32 digest ", + "= _hashTypedDataV4(" + ], + [ + "\"Insufficient ", + "Balance\"" + ], + [ + "call the ", + "safe operations " + ], + [ + ");\\n }\\n return ", + "computedHash" + ], + [ + "Ptr, ", + "and(" + ], + [ + "() external pure returns (string memory", + ");\\n function " + ], + [ + "bank", + "x" + ], + [ + "producing ", + "values on a " + ], + [ + "(when the ", + "token" + ], + [ + "index = ", + "end - " + ], + [ + "mix", + "in" + ], + [ + "(uint16 _srcChainId", + ", bytes calldata " + ], + [ + "baseTokenFor", + "Pair" + ], + [ + "outside ", + "of contract " + ], + [ + "computedHash = _", + "hashPair(computedHash, " + ], + [ + "reduce", + "Fee" + ], + [ + "\\n ) external returns (uint amountA, uint amountB", + ");\\n function " + ], + [ + "(\\n bytes32[] calldata proof", + ",\\n bool[] calldata " + ], + [ + "may", + "\\n * " + ], + [ + "proof[i]", + ");\\n }\\n return computedHash" + ], + [ + "_burnCounter - ", + "_startTokenId();\\n }\\n }\\n\\n /**\\n * @dev Returns the total amount of tokens minted in the contract.\\n */\\n function _totalMinted(" + ], + [ + "(uint256 a, uint256 b) internal pure returns (uint256) {\\n uint256 c = a + b;\\n require(c >= a, \\\"SafeMath: addition overflow", + "\\\");\\n return c" + ], + [ + "immedi", + "ately " + ], + [ + "Sa", + "toshis" + ], + [ + "OperatorFilterer {\\n ", + "/// @dev " + ], + [ + "_checkContractOnERC721Received(from, to, tokenId, _data", + ")) {\\n " + ], + [ + "PUT", + "_AMOUNT" + ], + [ + ", i.e. ", + "the " + ], + [ + ", bytes32 leaf) internal pure returns (bytes32) {\\n bytes32 computedHash = leaf;\\n for (uint256 i = 0; i < proof.length; i++) {\\n ", + "computedHash = _hashPair(computedHash, " + ], + [ + "owner != ", + "operator" + ], + [ + ",\\n address to", + ",\\n uint256 " + ], + [ + "return\\n interfaceId == 0x01ffc9a7 || ", + "// ERC165 interface ID for ERC165" + ], + [ + "cause ", + "an overflow" + ], + [ + "ownership = _ownership", + "At" + ], + [ + ").interfaceId || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev ", + "Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account" + ], + [ + "addLiquidityETH(\\n address token", + ",\\n uint amountTokenDesired,\\n uint amountTokenMin,\\n uint amountETHMin,\\n address to,\\n uint deadline" + ], + [ + "RoleAdminChanged(role", + ", previous" + ], + [ + "ont", + "o " + ], + [ + "ROLE_", + "ERC20" + ], + [ + "IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Enumerable is ", + "IERC721 {\\n /**\\n * @dev Returns the " + ], + [ + "which allows ", + "you to " + ], + [ + " bits\\r\\n *\\r\\n * ", + "_Available since v4." + ], + [ + "non-reverting calls are ", + "assumed to " + ], + [ + "abi.decode(returndata, (", + "bool)" + ], + [ + ", timestamp", + "()), " + ], + [ + "Tokens that ", + "return no " + ], + [ + "priz", + "es" + ], + [ + "_balances[recipient] += amount;\\n\\n emit Transfer", + "(sender, recipient, amount" + ], + [ + ", address indexed from, address indexed ", + "to" + ], + [ + ") external;\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev ", + "Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n}\\n\"" + ], + [ + "queue ", + "starts with the " + ], + [ + "MULT", + "IP" + ], + [ + "prettier-ignore\\n ", + "if iszero(" + ], + [ + "s\\\":[{\\\"", + "internalType\\\":\\\"" + ], + [ + "Emits a {Transfer} event ", + "with " + ], + [ + "revert(\\n string(\\n abi.encodePacked(\\n \\\"", + "AccessControl: account " + ], + [ + "Emergen", + "cy" + ], + [ + "BITPOS_NUMBER_BURNED) - 1", + ";\\n\\n // Updates:\\n // - `address` to the " + ], + [ + "sometimes called as ", + "'swap and pop" + ], + [ + "BITMASK_BURNED = 1 << 224", + ";\\n\\n // The bit position" + ], + [ + "Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * ", + "Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControl" + ], + [ + "length,\\n // ", + "and 3 " + ], + [ + "_approve(account, ", + "_msgSender(), " + ], + [ + "implementing it ourselves", + ". We " + ], + [ + ");\\n if (to.code.length != 0)\\n if (!", + "_checkContractOnERC721Received(from, to, tokenId, _data)) {\\n " + ], + [ + "starting token ID.\\n * To change the starting token ID", + ", please override this function.\\n */\\n function _startTokenId() internal view virtual returns (uint256) {\\n return 0;\\n }\\n\\n /**\\n * @dev Returns the next token ID to be minted.\\n */\\n function _nextTokenId" + ], + [ + "uint256) {\\n // Counter underflow is impossible as _burnCounter cannot be incremented\\n // more than `_currentIndex - _startTokenId()` ", + "times.\\n unchecked {\\n " + ], + [ + "Returns an Ethereum Signed Message, created from `s`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {\\n return ", + "keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n\\\", Strings.toString(s.length), s" + ], + [ + "over ``owner``'s tokens,\\n * given ``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as ", + "defined by {EIP712}.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\"" + ], + [ + "\"convex", + "-platform" + ], + [ + ";` ", + "statement to your contract" + ], + [ + "a,\\r\\n uint256 ", + "b" + ], + [ + "from` cannot be the zero address.\\n * - `", + "to` cannot be the zero address" + ], + [ + "burning.\\n // - `burned` to `", + "true`.\\n // - `nextInitialized` to `" + ], + [ + "\\n * @dev Wrappers ", + "around ERC20 operations that " + ], + [ + "last owner.\\n // - `startTimestamp` to the timestamp of ", + "burning.\\n // - `burned` to `true`.\\n // - `nextInitialized` to `" + ], + [ + ".\\n interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721", + ".\\n interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata." + ], + [ + "To use this library ", + "you can add a `" + ], + [ + "also supported, ", + "non-reverting calls are assumed to " + ], + [ + "if (!hasRole(role, account)) {\\n ", + "revert(\\n string(\\n abi.encodePacked(\\n \\\"AccessControl: account " + ], + [ + "next owner.\\n // - `startTimestamp` to the timestamp of ", + "transfering.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `" + ], + [ + "consuming and ", + "producing values on a " + ], + [ + "\\n ) external returns (uint amountToken, uint amountETH", + ");\\n function " + ], + [ + "returns false). ", + "Tokens that return no " + ], + [ + "as `token.safeTransfer(", + "...)`, " + ], + [ + "ensureInputLength", + "Match" + ], + [ + "mload(add(table", + "Ptr, and(" + ], + [ + "\\n\\n // Updates:\\n // - `address` to the ", + "next owner.\\n // - `startTimestamp` to the timestamp of transfering.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `" + ], + [ + "`.\\n // - `numberBurned += 1", + "`.\\n //\\n // We can directly decrement the balance, and increment the number burned" + ], + [ + ".\\n unchecked {\\n // We can directly increment and decrement the balances", + ".\\n " + ], + [ + ".\\n unchecked {\\n // Updates:\\n // - `balance -= 1", + "`.\\n // - `numberBurned += 1`.\\n //\\n // We can directly decrement the balance, and increment the number burned" + ], + [ + "throw on failure ", + "(when the token" + ], + [ + "throw on failure) are ", + "also supported, non-reverting calls are assumed to " + ], + [ + "value (and instead ", + "revert " + ], + [ + "call the safe operations ", + "as `token.safeTransfer(...)`, " + ], + [ + "index = end - ", + "quantity" + ], + [ + "(\\n bytes32[] calldata proof,\\n bool[] calldata ", + "proofFlags" + ], + [ + ", bytes32 leaf) internal pure returns (bytes32) {\\n bytes32 computedHash = leaf;\\n for (uint256 i = 0; i < proof.length; i++) {\\n computedHash = _hashPair(computedHash, ", + "proof[i]);\\n }\\n return computedHash" + ], + [ + "return\\n interfaceId == 0x01ffc9a7 || // ERC165 interface ID for ERC165", + ".\\n interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721.\\n interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata." + ], + [ + "RoleAdminChanged(role, previous", + "AdminRole, adminRole" + ], + [ + "which allows you to ", + "call the safe operations as `token.safeTransfer(...)`, " + ], + [ + "BITPOS_NUMBER_BURNED) - 1;\\n\\n // Updates:\\n // - `address` to the ", + "last owner.\\n // - `startTimestamp` to the timestamp of burning.\\n // - `burned` to `true`.\\n // - `nextInitialized` to `" + ], + [ + "sometimes called as 'swap and pop", + "').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex" + ], + [ + "\"convex-platform", + "/contracts/contracts/" + ], + [ + "\\n * @dev Wrappers around ERC20 operations that ", + "throw on failure (when the token" + ], + [ + "consuming and producing values on a ", + "queue" + ], + [ + "returns false). Tokens that return no ", + "value (and instead revert " + ], + [ + ".\\n unchecked {\\n // Updates:\\n // - `balance -= 1`.\\n // - `numberBurned += 1`.\\n //\\n // We can directly decrement the balance, and increment the number burned", + ".\\n // This is equivalent to `packed -= 1; packed += 1" + ], + [ + "which allows you to call the safe operations as `token.safeTransfer(...)`, ", + "etc" + ], + [ + "\"", + "0" + ], + [ + ")", + ");\\n return " + ], + [ + "0", + "];\\n } else {\\n return " + ], + [ + "2", + "000" + ], + [ + "9", + "24" + ], + [ + ":", + "\\n // - " + ], + [ + "D", + "EX" + ], + [ + "F", + "requency " + ], + [ + "I", + "Get" + ], + [ + "S", + "w" + ], + [ + "S", + "UPP" + ], + [ + "V", + "ote" + ], + [ + "X", + "\"" + ], + [ + "[", + "xxx" + ], + [ + "_", + "project" + ], + [ + "_", + "state" + ], + [ + "_", + "accounts" + ], + [ + "_", + "hashPair" + ], + [ + "_", + "MANAG" + ], + [ + "`", + "quantity" + ], + [ + "`", + "aux" + ], + [ + "`", + "nextInitialized` " + ], + [ + "`", + "(quantity == 1" + ], + [ + "c", + "0" + ], + [ + "f", + "ter" + ], + [ + "g", + "old" + ], + [ + "k", + "o" + ], + [ + "m", + "atch " + ], + [ + "s", + "Token" + ], + [ + " ", + "ADDRESS" + ], + [ + "\\n", + "{\\n " + ], + [ + "\\n", + "@@@@@@@@@@@@@@@@@@@@@@@@" + ], + [ + "\\n ", + ");\\n " + ], + [ + "re", + "voc" + ], + [ + "s ", + "values are " + ], + [ + "in", + "f" + ], + [ + ", ", + "balance" + ], + [ + ", ", + "EIP712" + ], + [ + ", ", + "uint16 " + ], + [ + ", ", + "uint24 extraData" + ], + [ + "un", + "wrap" + ], + [ + "256", + "bit " + ], + [ + "uint256", + ")\\\"))" + ], + [ + "\\n * ", + "an " + ], + [ + "\\n * ", + "pair of " + ], + [ + "tr", + "ailing " + ], + [ + "at", + "ew" + ], + [ + "token", + ".\\n * " + ], + [ + "it", + "yt" + ], + [ + "co", + "sum" + ], + [ + "se", + "s are done " + ], + [ + "\\\"", + ".\\n " + ], + [ + "\\\"", + "pop" + ], + [ + "\\\"", + ". If " + ], + [ + "\\\"", + "pointers" + ], + [ + "` ", + "- the " + ], + [ + "` ", + "field" + ], + [ + "` ", + "have a " + ], + [ + "uint256 ", + "value" + ], + [ + "\\n *", + " - " + ], + [ + "no", + "te" + ], + [ + "value", + "_" + ], + [ + " = ", + "amount" + ], + [ + " = ", + "leaves" + ], + [ + ".\\n */\\n function ", + "verify" + ], + [ + ",\\n ", + "function" + ], + [ + ");\\n ", + "_owner = newOwner" + ], + [ + ") {\\n ", + "ownership.addr = address(uint160(packed));\\n ownership.startTimestamp = uint64(" + ], + [ + "(address ", + "minter" + ], + [ + "and ", + "value for the " + ], + [ + "} ", + "as defined " + ], + [ + "\\n ", + "? " + ], + [ + "\\n ", + ");\\n " + ], + [ + "total", + " of " + ], + [ + "total", + "Minted" + ], + [ + ";\\n ", + "bytes32 " + ], + [ + "), ", + "eq(msgSender, " + ], + [ + "Cont", + "ain" + ], + [ + "from ", + "rightmost dig" + ], + [ + "by ", + "travers" + ], + [ + "add", + "ing " + ], + [ + "msgSender", + " := and(" + ], + [ + "if (", + "currOwnershipAddr == owner" + ], + [ + "balance", + "1" + ], + [ + "be", + "have " + ], + [ + "string ", + "constant " + ], + [ + "max", + "TokenSupplyForStage" + ], + [ + "nam", + "ic" + ], + [ + "Call", + "ed " + ], + [ + "the", + "\\n // " + ], + [ + "This ", + "account " + ], + [ + "current", + "Invariant" + ], + [ + ";\\n\\n", + "library " + ], + [ + ";\\n\\n", + "import \\u0027./" + ], + [ + ");\\n\\n ", + "error " + ], + [ + "with ", + "verification of " + ], + [ + ");\\n\\n ", + "return (" + ], + [ + ";\\n\\n ", + "/// " + ], + [ + "Mint", + "s `quantity` tokens and transfers them to `to`.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `quantity` must be greater than 0" + ], + [ + "'s ", + "\\\"pop" + ], + [ + ", \\\"", + "S" + ], + [ + "ill", + "create" + ], + [ + " * ", + "n" + ], + [ + "per", + "son" + ], + [ + " ", + "The " + ], + [ + "ting ", + "ERC721 " + ], + [ + "bytes32 ", + "a = " + ], + [ + "bytes32 ", + "b = " + ], + [ + "IN", + "EL" + ], + [ + "balanceOf", + "(from" + ], + [ + "mod", + "s" + ], + [ + "// S", + "tore" + ], + [ + "`from", + "TokenId" + ], + [ + "Swap", + "Tokens" + ], + [ + "com", + "position" + ], + [ + " of the ", + "chain" + ], + [ + "\"// SPDX-License-Identifier: ", + "Apache-2.0" + ], + [ + ";\\n ", + "bytes32 private immutable _" + ], + [ + ".\\n */\\n function _", + "require" + ], + [ + "hash", + "Po" + ], + [ + "hash", + "es on the " + ], + [ + "hash", + ".\\n // - " + ], + [ + "hash", + "es = new " + ], + [ + "` cannot be ", + "set on " + ], + [ + "(_", + "srcChainId" + ], + [ + "+ ", + "proof" + ], + [ + "s, ", + "leaves" + ], + [ + "` to ", + "`toTokenId" + ], + [ + "amount ", + "-= " + ], + [ + "set ", + "if `" + ], + [ + "If ", + "not burned" + ], + [ + " != ", + "0;\\n " + ], + [ + "only ", + "one {" + ], + [ + ":= ", + "extraData" + ], + [ + "in the ", + "`hashes" + ], + [ + "String", + "Slot" + ], + [ + "].", + "\\n * " + ], + [ + "fi", + "eld " + ], + [ + "En", + "ables " + ], + [ + " == ", + "totalHashes" + ], + [ + "`tokenId` ", + "has a " + ], + [ + "using ", + "two values" + ], + [ + "Pool", + "Points" + ], + [ + "24", + "bit " + ], + [ + "24", + " bits for `" + ], + [ + "_mint", + "(to, amount" + ], + [ + "\\\");\\n\\n ", + "// The " + ], + [ + "quantity", + ", 1" + ], + [ + "oper", + "ating" + ], + [ + "::", + "permit" + ], + [ + "grant", + "Role(" + ], + [ + "non-", + "compliant with the " + ], + [ + "storage ", + "tokenApproval" + ], + [ + ";\\r\\n", + "\\r\\n " + ], + [ + "3.", + "68" + ], + [ + ") public view virtual override returns (", + "uint256) {\\r\\n return " + ], + [ + "ENT", + "INEL" + ], + [ + "round", + "Up" + ], + [ + "should ", + "contain the " + ], + [ + "proof", + "` must be " + ], + [ + "proof", + "s can be " + ], + [ + "proof", + "s.\\n *\\n * The " + ], + [ + "proof", + "[0];\\n " + ], + [ + "proof", + "[proof" + ], + [ + "(from, to, ", + "extraData" + ], + [ + "(address account", + ", address " + ], + [ + "es[", + "i" + ], + [ + "signature", + "\\n * @param " + ], + [ + "Po", + "s values are " + ], + [ + "ing the ", + "tree up" + ], + [ + "using", + "\\n // `" + ], + [ + "token/ERC20/", + "SafeERC20" + ], + [ + "`owner", + " | (" + ], + [ + "tic ", + "due to the " + ], + [ + "gas ", + "optimization" + ], + [ + "spec", + "ial " + ], + [ + "DRE", + "AM" + ], + [ + "For ", + "branchless " + ], + [ + ");\\n _", + "packedAddressData[owner" + ], + [ + "temp", + ") { break " + ], + [ + "\\\");\\n require(", + "_" + ], + [ + "sol", + "ad" + ], + [ + "packed ", + "== 0) {\\n " + ], + [ + "Router0", + "2" + ], + [ + "0.8.", + "9" + ], + [ + "0.8.", + "13" + ], + [ + ".sol\\\";\\n\\n/**\\n * @dev ", + "Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\\n *\\n * These functions can be used to verify that a message was signed by the holder\\n * of the private keys of a given address.\\n */\\nlibrary ECDSA {\\n enum RecoverError {\\n NoError,\\n InvalidSignature,\\n InvalidSignatureLength,\\n InvalidSignatureS,\\n InvalidSignatureV" + ], + [ + " from ", + "the\\n // " + ], + [ + "ing\\n * ", + "sibling " + ], + [ + "Chang", + "e " + ], + [ + "into ", + "position" + ], + [ + "- `", + "spender` cannot be the zero address" + ], + [ + "Balance ", + "exceeds " + ], + [ + ";\\n emit ", + "RoleAdminChanged(role, previousAdminRole, adminRole" + ], + [ + "array", + ". All " + ], + [ + "asset", + "s, " + ], + [ + "asset", + "s` " + ], + [ + "T_", + "ROLE" + ], + [ + "with the ", + "ERC2309" + ], + [ + "Round", + "s" + ], + [ + "aul", + "t to " + ], + [ + "Emitted when ", + "tokens in " + ], + [ + "Wei", + "ght = " + ], + [ + "to the ", + "root of the tree. " + ], + [ + "the caller ", + "is " + ], + [ + "each ", + "token transfer to " + ], + [ + "each ", + "array. All " + ], + [ + "have been ", + "consum" + ], + [ + "Liqui", + "date" + ], + [ + " overflow", + "s on the " + ], + [ + "we", + "\\n // " + ], + [ + "contain", + "ing\\n * sibling " + ], + [ + "Strings", + ".sol\\\";\\n\\n/**\\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\\n *\\n * These functions can be used to verify that a message was signed by the holder\\n * of the private keys of a given address.\\n */\\nlibrary ECDSA {\\n enum RecoverError {\\n NoError,\\n InvalidSignature,\\n InvalidSignatureLength,\\n InvalidSignatureS,\\n InvalidSignatureV" + ], + [ + "ERC721 ", + "standard" + ], + [ + "ERC721 ", + "compli" + ], + [ + "equivalent to ", + "`approved" + ], + [ + ")\\n ", + "let " + ], + [ + "expect", + "ed to be " + ], + [ + "for (uint256 i", + "; i" + ], + [ + "ance", + ", sub" + ], + [ + "setting", + " of the `nextInitialized` " + ], + [ + " or ", + "the " + ], + [ + "next ", + "value to " + ], + [ + "pric", + "e that " + ], + [ + ") {\\n // ", + "This function " + ], + [ + "extraData", + "` before " + ], + [ + "extraData", + "(from, to, extraData" + ], + [ + "reasury", + "dao" + ], + [ + "encod", + "ed" + ], + [ + "} event.\\n */\\n function _", + "mint" + ], + [ + ".\\n", + "\\n // " + ], + [ + "s.length", + ";\\n\\n // Check " + ], + [ + "permis", + "sible " + ], + [ + "make ", + "your contract" + ], + [ + "sha", + "red" + ], + [ + ");\\r\\n\\r\\n ", + "uint256 " + ], + [ + "swapExactTokensForETHSupportingFeeOnTransferTokens", + "(\\n uint amountIn,\\n uint amountOutMin,\\n address[] calldata path,\\n address to,\\n uint deadline\\n " + ], + [ + "(address(0), to, ", + "index" + ], + [ + ". The ", + "root is " + ], + [ + ". The ", + "queue starts with the " + ], + [ + "Param", + "s(" + ], + [ + "flag", + ", either " + ], + [ + "result is ", + "shifted " + ], + [ + "calcul", + "ated" + ], + [ + "uint160", + "(account" + ], + [ + "\\ti", + "f " + ], + [ + "sale", + "Price * " + ], + [ + "consum", + "e in " + ], + [ + "src/", + "\"" + ], + [ + "TION", + " " + ], + [ + ") external returns (", + "uint256 " + ], + [ + ");\\n uint256 ", + "leafPo" + ], + [ + "hash ", + "by travers" + ], + [ + "hash ", + "in the `hashes" + ], + [ + "hash ", + "using two values" + ], + [ + "register", + "Tokens" + ], + [ + "Remo", + "ves " + ], + [ + "leaves", + ". The root is " + ], + [ + "Start", + "Time " + ], + [ + "returned ", + "result is shifted " + ], + [ + "Proxy", + "Owner" + ], + [ + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../", + "ERC20.sol\\\";\\nimport \\\"../../../" + ], + [ + "ERC2309", + " exceeds the " + ], + [ + "ownership.", + "extraData = uint24(" + ], + [ + "licen", + "se " + ], + [ + "// The ", + "following is " + ], + [ + "a `", + "leaf` " + ], + [ + "a `", + "proof` must be " + ], + [ + "} else if (", + "leavesLen " + ], + [ + ", we ", + "compute the next " + ], + [ + "_startTokenId", + "() " + ], + [ + "`index", + "`.\\n */\\n function _" + ], + [ + "root", + "`. For " + ], + [ + "For a ", + "limit of " + ], + [ + "_isExcludedMaxTransactionAmount", + "[to]" + ], + [ + "\\n */\\n ", + "error " + ], + [ + "root ", + "of\\n // the " + ], + [ + "root ", + "hash by travers" + ], + [ + "queri", + "ed" + ], + [ + "called", + ".\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals" + ], + [ + "BITMASK_ADDRESS", + " = (1 << " + ], + [ + "leaves ", + "and each " + ], + [ + "leaves ", + "have been consum" + ], + [ + "[_", + "of" + ], + [ + " = 2", + "32" + ], + [ + " = 0x", + "360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc" + ], + [ + "cannot overflow", + ".\\r\\n */\\r\\n function " + ], + [ + "`, which ", + "return the current value and " + ], + [ + ";\\n\\n ", + "/**\\n * @dev " + ], + [ + "(\\r\\n address ", + "indexed " + ], + [ + "; i++) {\\n ", + "bytes32 a = " + ], + [ + "set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `", + "to` cannot be the zero address" + ], + [ + "quantity` ", + "equals 1" + ], + [ + "quantity` ", + "that can be minted " + ], + [ + "Max ", + "Transaction " + ], + [ + "ln", + "_36" + ], + [ + "at(", + "index" + ], + [ + "token id", + "s are " + ], + [ + ", which is ", + "unrealistic" + ], + [ + "uniswap", + "Router" + ], + [ + "full ", + "ERC721 compli" + ], + [ + "bytes32[] memory ", + "hashes = new " + ], + [ + " is only ", + "permissible " + ], + [ + "Random", + "izer" + ], + [ + "\\n ) internal pure returns (", + "bytes32 merkleRoot" + ], + [ + "totalHash", + "es = " + ], + [ + "VRF", + "Coordinator" + ], + [ + "unrealis", + "tic due to the " + ], + [ + "maximum `", + "quantity` that can be minted " + ], + [ + "proofFlag", + "s, leaves" + ], + [ + "proofFlag", + "s.length;\\n\\n // Check " + ], + [ + "`\\n // - [", + "160..223] `startTimestamp" + ], + [ + "`\\n // - [", + "64..127] `numberMinted" + ], + [ + "`\\n // - [", + "128..191] `numberBurned" + ], + [ + "`\\n // - [", + "224] `burned" + ], + [ + "`\\n // - [", + "192..255] `aux" + ], + [ + "`\\n // - [", + "225] `nextInitialized" + ], + [ + "\\n * a ", + "default value of 18" + ], + [ + "in a ", + "packed ownership " + ], + [ + "\\n virtual\\n override", + "\\n " + ], + [ + "govern", + "or" + ], + [ + "utils/Strings", + ".sol\\\";\\nimport \\\"../" + ], + [ + "votes ", + ": 0" + ], + [ + "ceil", + "ing" + ], + [ + "the\\n // ", + "`hashes" + ], + [ + "domain", + "separator" + ], + [ + "above ", + "check for " + ], + [ + "thus ", + "mim" + ], + [ + "232", + "..255] `" + ], + [ + "reset", + "ting " + ], + [ + "BITPOS_EXTRA_DATA", + " = 232" + ], + [ + "packOwnershipData", + "(address owner, uint256 " + ], + [ + "value == 0", + ") || (" + ], + [ + "ed for ", + "efficient minting " + ], + [ + "Sp", + "ender" + ], + [ + "{\\n /**\\n * @dev Returns true if ", + "a `leaf` " + ], + [ + "uint24 ", + "extraData = uint24(" + ], + [ + "a value ", + "from the \\\"main queue" + ], + [ + "ConsecutiveTransfer", + "(uint256 indexed " + ], + [ + "ConsecutiveTransfer", + "} as defined " + ], + [ + "IMPLEMENTATION_SLOT", + " = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc" + ], + [ + "uint256(_", + "extraData(from, to, extraData" + ], + [ + "500", + "0, a " + ], + [ + ".\\n //", + "/\\n /// " + ], + [ + "lower 160", + " bits for " + ], + [ + "queue", + "'s \\\"pop" + ], + [ + "s) ", + "with the ERC2309" + ], + [ + "BITPOS_START_TIMESTAMP", + ") | " + ], + [ + "BITPOS_START_TIMESTAMP", + ", timestamp()), " + ], + [ + "Active ", + "= " + ], + [ + ".\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply ", + "= _totalSupply.add(amount);\\n _balances[account] = _balances[account].add(amount);\\n emit Transfer" + ], + [ + "` array", + ", then " + ], + [ + "` array", + ".\\n for (uint256 i = 0; i < " + ], + [ + "` array", + ". At the " + ], + [ + "from != ", + "to" + ], + [ + "set the ", + "24bit " + ], + [ + "commun", + "ityt" + ], + [ + "BITMASK_NEXT_INITIALIZED", + " |" + ], + [ + "try ", + "ERC721A__IERC721Receiver(to).onERC721Received" + ], + [ + "(a, b", + ");\\n }\\n\\n if (" + ], + [ + " = (1 << ", + "232" + ], + [ + "totalHashes", + ");\\n uint256 leafPo" + ], + [ + "totalHashes", + "; i++) {\\n bytes32 a = " + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/", + "math/Math.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n enum Rounding {\\n Down, // Toward negative infinity\\n Up, // Toward infinity\\n Zero // Toward zero\\n }\\n\\n /**\\n * @dev Returns the largest of two numbers.\\n */\\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a > b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2;\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute.\\n return a == 0 ? 0 : (a - 1) / b + 1;\\n }\\n\\n /**\\n * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\\n * with further edits by Uniswap Labs also under MIT license" + ], + [ + "5` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless ", + "{_setupDecimals" + ], + [ + "callable ", + "by " + ], + [ + "\\\" (", + "merging " + ], + [ + "hashes[", + "totalHashes " + ], + [ + "hashes[", + "i] = _" + ], + [ + " from the ", + "leaves. The root is " + ], + [ + "otherwise ", + "we\\n // " + ], + [ + "leavesLen ", + "+ proof" + ], + [ + "Sync", + "(" + ], + [ + "acces", + "ses are done " + ], + [ + "toggle", + "Swap" + ], + [ + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n ", + "_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)" + ], + [ + "_packedOwnerships", + ";\\n\\n // Mapping owner address to address data" + ], + [ + "BITPOS_AUX", + ");\\n _packedAddressData[owner" + ], + [ + "    ", + "    " + ], + [ + "\\n //\\n // ", + "Bits Layout:\\n // - [0.." + ], + [ + "`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this ", + "token\\n * by either {approve} or {setApprovalForAll}.\\n * - " + ], + [ + "BITPOS_NEXT_INITIALIZED", + ", eq(" + ], + [ + "300", + "9" + ], + [ + "leaf ", + "to the root of the tree. " + ], + [ + "proof ", + "validity" + ], + [ + "nextInitializedFlag", + "(uint256 quantity" + ], + [ + "Merkle ", + "T" + ], + [ + "BITMASK_BURNED", + " |" + ], + [ + ".\\n uint256 private ", + "_burnCounter;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to ownership details\\n // An empty struct value does not necessarily mean the token is unowned" + ], + [ + ".\\n uint256 private ", + "_currentIndex;\\n\\n // The number of tokens burned" + ], + [ + "\"// SPDX-License-Identifier: GPL-3.0-or-later\\n// This program is free software: you can redistribute it and/or modify\\n// it under the terms of the GNU General Public License as published by\\n// the Free Software Foundation, either version 3 of the License, or\\n// (at your option) any later version.\\n\\n// This program is distributed in the hope that it will be useful,\\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\n// GNU General Public License for more details.\\n\\n// You should have received a copy of the GNU General Public License\\n// along with this program. If not, see .\\n\\npragma solidity ^0.7.0", + ";\\npragma experimental ABIEncoderV2" + ], + [ + ".\\r\\n */", + "\\r\\n event " + ], + [ + "branc", + "h from the " + ], + [ + "approvedAddress ", + ":= sload(" + ], + [ + "end of the ", + "process, the last " + ], + [ + "At(uint256 index", + ", uint24 extraData" + ], + [ + ";\\n\\n // Mapping from token ID to approved address", + ".\\n mapping(uint256 => " + ], + [ + ".\\n uint256 ", + "leavesLen" + ], + [ + "xxx", + "[xxx" + ], + [ + "xxx", + "Pos values are " + ], + [ + "facilit", + "ate " + ], + [ + "startTokenId + ", + "quantity - 1" + ], + [ + "distribution", + "Contract" + ], + [ + ");\\n uint256 c = ", + "a / b" + ], + [ + "hashPair", + "(a, b);\\n }\\n\\n if (" + ], + [ + ") {\\n assembly {\\n // ", + "The maximum value of a uint256 contains 78 digits (1 byte per digit" + ], + [ + "`balance` and `numberMinted", + "` have a " + ], + [ + "leaves[", + "0];\\n } else {\\n return " + ], + [ + "`extraData", + "` field" + ], + [ + "Hal", + "f " + ], + [ + "Mask `", + "msgSender" + ], + [ + "() external view override returns (", + "bytes32) {\\n return _" + ], + [ + "contains ", + "contract " + ], + [ + "each step", + ", we compute the next " + ], + [ + "pair of ", + "pre-images are assumed to be sorted" + ], + [ + "(proof, ", + "proofFlags, leaves" + ], + [ + ");\\n }\\n\\n /**\\n * @dev Approve ", + "`operator` to operate on all of `owner` tokens" + ], + [ + "mapping(bytes32 => ", + "RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to", + "`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token\\n * by either {approve} or {setApprovalForAll}.\\n * - " + ], + [ + "community", + "mods" + ], + [ + "Address.", + "isContract(" + ], + [ + "These functions ", + "deal " + ], + [ + ") external returns(", + "bool)" + ], + [ + "Address = _", + "tokenApproval" + ], + [ + "STORAGE", + "\\n //////////////////////////////////////////////////////////////*/\\n\\n " + ], + [ + "sim", + "ultane" + ], + [ + "Role = ", + "getRoleAdmin(role" + ], + [ + ".\\n */\\n function _safeMint(\\n address to", + ",\\n uint256 quantity" + ], + [ + "an element", + " from the\\n // " + ], + [ + "override returns (bool) {\\n ", + "// The interface IDs are constants representing the first 4" + ], + [ + "_EXTRA_DATA_COMPLEMENT", + " = (1 << 232" + ], + [ + "MAX_MINT_ERC2309_QUANTITY_LIMIT", + " = 5000" + ], + [ + "previousExtraData", + "` - the " + ], + [ + "9e", + "15 " + ], + [ + "except the ", + "24 bits for `" + ], + [ + "`proof", + "` array.\\n for (uint256 i = 0; i < " + ], + [ + "(_msgSenderERC721A(), ", + "from, tokenId, _data) returns (" + ], + [ + "into a single ", + "uint256" + ], + [ + "address data ", + "entries." + ], + [ + "increment the ", + "pointer, " + ], + [ + "auxiliary data for `owner`. (e.g. number of whitelist mint slots used", + ").\\n * If there are multiple variables, please pack them into a uint64.\\n */\\n function _setAux(address owner, uint64 aux" + ], + [ + "auxiliary data for `owner`. (e.g. number of whitelist mint slots used", + ").\\n */\\n function _getAux(address owner) internal view returns (uint64) {\\n return " + ], + [ + "> 0) {\\n return ", + "leaves[0];\\n } else {\\n return " + ], + [ + "s = 0;\\n uint256 ", + "proofPo" + ], + [ + "s = 0;\\n uint256 ", + "hashPo" + ], + [ + "ownership data ", + "into a single uint256" + ], + [ + "extraDataCasted ", + ":= extraData" + ], + [ + "maximum limit of ", + "2**256" + ], + [ + "maximum limit of ", + "2**64." + ], + [ + ".\\n *\\n * Emits a {Transfer} event for each mint", + ".\\n */\\n function _mint" + ], + [ + ".\\n *\\n * Emits a {Transfer} event for each mint", + ".\\n */\\n function _safeMint(\\n address to,\\n uint256 quantity" + ], + [ + "get the next ", + "leaf, " + ], + [ + "get the next ", + "hash.\\n // - " + ], + [ + "Pos++];\\n ", + "bytes32 b = " + ], + [ + "Pos++];\\n ", + "hashes[i] = _" + ], + [ + "extra data for the ", + "packed ownership " + ], + [ + "extra data for the ", + "ownership data " + ], + [ + "{Transfer} event(", + "s) with the ERC2309" + ], + [ + "leafPos < leavesLen ? leaves[leafPos++] : hashes[hash", + "Pos++];\\n bytes32 b = " + ], + [ + "https://eips.ethereum.org/EIPS/eip-712#definition-of-", + "domainseparator" + ], + [ + "rebuilt ", + "by\\n // " + ], + [ + "Equivalent to `safeTransferFrom(from, to, tokenId, '')`.\\n */\\n function ", + "safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n " + ], + [ + "caller is not token ", + "owner or " + ], + [ + "inclusive", + ") is " + ], + [ + "EXP", + "IRED" + ], + [ + "this, ", + "a `proof` must be " + ], + [ + "signed", + "MintValidation" + ], + [ + "sets the ", + "extra data for the ownership data " + ], + [ + "depending on the ", + "flag, either " + ], + [ + "manifold", + ".xyz" + ], + [ + "safety ", + "limit" + ], + [ + "Descri", + "ption" + ], + [ + "eco", + "system " + ], + [ + "implementation for details.", + "\\n //\\n // Bits Layout:\\n // - [0.." + ], + [ + "`\\n ", + "mapping(address => uint256) private _packedAddressData" + ], + [ + "startTimestamp` ", + "that can be set " + ], + [ + "intend", + "ed for efficient minting " + ], + [ + "primiti", + "ve" + ], + [ + "s = 0;\\n ", + "// At " + ], + [ + ")\\n private\\n view\\n returns (", + "uint256 " + ], + [ + "if (!_checkContractOnERC721Received", + "(address(0), to, index" + ], + [ + "data s", + "imilar to `" + ], + [ + "(from, address(0), ", + "prevOwnershipPacked" + ], + [ + "flag ", + "set if `" + ], + [ + "`leaves", + "` array, then " + ], + [ + ") or ", + "an element from the\\n // " + ], + [ + "TYPE_HASH", + ", _" + ], + [ + "` array ", + "should contain the " + ], + [ + "provided, ", + "containing\\n * sibling " + ], + [ + "limit is ", + "to prevent" + ], + [ + "} is\\n * ", + "called.\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals" + ], + [ + "Accumul", + "ator" + ], + [ + ".\\n require(", + "leavesLen + proof" + ], + [ + "creation ", + "WILL " + ], + [ + "IERC721A {\\n /**\\n * ", + "The caller must own the token or be an approved operator.\\n */\\n error ApprovalCallerNotOwnerNorApproved();\\n\\n /**\\n * The token does not exist.\\n */\\n error ApprovalQueryForNonexistentToken" + ], + [ + "equival", + "ent" + ], + [ + "tree\\n * ", + "defined by `" + ], + [ + "JavaScript ", + "library" + ], + [ + "goes ", + "onto " + ], + [ + ", prevOwnership", + "Packed" + ], + [ + "storage slot ", + "and value for the " + ], + [ + "members;\\n bytes32 adminRole;\\n }\\n\\n ", + "mapping(bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev " + ], + [ + "thres", + "hold" + ], + [ + "` to be ", + "below the " + ], + [ + "tokenId < _currentIndex && ", + "// If within bound" + ], + [ + "} 1 {", + "} {\\n " + ], + [ + "using SafeERC20 for IERC20", + ";` statement to your contract" + ], + [ + ".sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC20} interface.\\n *\\n * This implementation is agnostic to the way tokens are created. This means\\n * that a supply mechanism has to be added in a derived contract using {_mint}.\\n * For a generic mechanism see {ERC20PresetMinterPauser}.\\n *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.", + "zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin guidelines: functions revert instead\\n * of returning `false` on failure. This behavior is nonetheless conventional\\n * and does not conflict with the expectations of ERC20 " + ], + [ + "] <= ", + "2500" + ], + [ + "merkle tree", + ".\\n uint256 leavesLen" + ], + [ + "stitu", + "ting ERC721 " + ], + [ + "Starting", + "Index" + ], + [ + "Each", + "\\n * pair of " + ], + [ + "(address from, address to, uint256 amount) internal virtual { ", + "}\\n}\\n\"" + ], + [ + "mapping(address => bool) ", + "members;\\n bytes32 adminRole;\\n }\\n\\n mapping(bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev " + ], + [ + "PERMIT_TYPEHASH, owner, ", + "spender, value" + ], + [ + "(success, ", + ") = " + ], + [ + ".\\n *\\n * To ", + "select a different value for {decimals}, use {_setupDecimals" + ], + [ + ".length;\\n uint256 ", + "totalHashes = " + ], + [ + "string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,0", + "5` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals" + ], + [ + "value of `", + "extraData` before " + ], + [ + "Arbitrary ", + "data similar to `" + ], + [ + "MerkleProof ", + "{\\n /**\\n * @dev Returns true if a `leaf` " + ], + [ + "can be proved to be a part of a Merkle ", + "tree\\n * defined by `" + ], + [ + "ande", + "arn" + ], + [ + "(from, to", + ", prevOwnershipPacked" + ], + [ + "uint256[] memory tokenId", + "s = new uint256" + ], + [ + "(sender, recipient, amount);\\n\\n ", + "_balances[sender] = _balances[sender].sub(amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[recipient] = _balances[recipient].add(amount);\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` " + ], + [ + "fromTokenId, uint256 toTokenId", + ", address indexed from, address indexed to" + ], + [ + "is required to ", + "cause an overflow" + ], + [ + "msgSender == ", + "approvedAddress" + ], + [ + "Intended to be ", + "overridden by the " + ], + [ + "hardh", + "at" + ], + [ + "address(token).", + "functionCall" + ], + [ + "sequence of ", + "{Transfer} event(" + ], + [ + "bytes memory returndata = ", + "address(token).functionCall" + ], + [ + "It emits ", + "only one {" + ], + [ + "instead of a ", + "sequence of {Transfer} event(" + ], + [ + "ed, we ", + "get the next leaf, " + ], + [ + "mask of the ", + "lower 160 bits for " + ], + [ + "icking a ", + "queue's \\\"pop" + ], + [ + "Pos++]", + "`, which return the current value and " + ], + [ + "159] `addr", + "`\\n // - [160..223] `startTimestamp" + ], + [ + "}, initializes {decimals} with", + "\\n * a default value of 18" + ], + [ + "We can directly compare the packed ", + "value." + ], + [ + "63] `balance", + "`\\n // - [64..127] `numberMinted" + ], + [ + "ed during ", + "each token transfer to " + ], + [ + "Directly ", + "sets the extra data for the ownership data " + ], + [ + ") internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, _data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _owners[tokenId] != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n ", + "require(_exists(tokenId), \\\"ERC721: operator query for nonexistent token\\\");\\n address owner = ERC721.ownerOf(tokenId);\\n return (spender == owner || " + ], + [ + "toHexString(uint256(role), 32)\\n )\\n )\\n ", + ");\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role" + ], + [ + "t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\\n * instead returning `false` on failure. This behavior is nonetheless\\n * conventional and does not conflict with the expectations of ERC20\\n * applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20 is Context, IERC20, IERC20Metadata {\\n mapping(address => uint256) private _balances;\\n\\n mapping(address => mapping(address => uint256)) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol;\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * The default value of {decimals} is 18. To select a different value for\\n * {decimals} you should overload it.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev Returns the symbol of the token, usually a shorter version of the\\n * name.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5.05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\\n * overridden;\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals() public view virtual override returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual override returns (uint256) {\\n return _balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - the caller must have a balance of at least `amount`.\\n */\\n function transfer(address to, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _transfer(owner, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n return _allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, amount);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-transferFrom}.\\n *\\n * Emits an {Approval} event indicating the updated allowance. This is not\\n * required by the EIP. See the note at the beginning of {ERC20}.\\n *\\n * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n * - the caller must have allowance for ``from``'s tokens of at least\\n * `amount`.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 amount\\n ) public virtual override returns (bool) {\\n address spender = _msgSender();\\n _spendAllowance(from, spender, amount);\\n _transfer(from, to, amount);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, allowance(owner, spender) + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n address owner = _msgSender();\\n uint256 currentAllowance = allowance(owner, spender);\\n require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - subtractedValue);\\n }\\n\\n return true;\\n }\\n\\n /**\\n * @dev Moves `amount` of tokens from `from` to `to`.\\n *\\n * This internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `from` must have a balance of at least `amount`.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {\\n require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(to != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, amount);\\n\\n uint256 fromBalance = _balances[from];\\n require(fromBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n unchecked {\\n _balances[from] = fromBalance - amount;\\n // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\\n // decrementing then incrementing.\\n _balances[to] += amount;\\n }\\n\\n emit Transfer(from, to, amount);\\n\\n _afterTokenTransfer(from, to, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n */\\n function _mint(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n _beforeTokenTransfer(address(0), account, amount);\\n\\n _totalSupply += amount;\\n unchecked {\\n // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\\n _balances[account] += amount;\\n }\\n emit Transfer(address(0), account, amount);\\n\\n _afterTokenTransfer(address(0), account, amount);\\n }\\n\\n /**\\n * @dev Destroys `amount` tokens from `account`, reducing the\\n * total supply.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n * - `account` must have at least `amount` tokens.\\n */\\n function _burn(address account, uint256 amount) internal virtual {\\n require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n _beforeTokenTransfer(account, address(0), amount);\\n\\n uint256 accountBalance = _balances[account];\\n require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n unchecked {\\n _balances[account] = accountBalance - amount;\\n // Overflow not possible: amount <= accountBalance <= totalSupply.\\n _totalSupply -= amount;\\n }\\n\\n emit Transfer", + "(account, address(0), amount);\\n\\n _afterTokenTransfer(account, address(0), amount);\\n }\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\\n *\\n * This internal function is equivalent to `approve`, and can be used to\\n * e.g. set automatic allowances for certain subsystems, etc.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `owner` cannot be the zero address.\\n * - `spender` cannot be the zero address.\\n */\\n function _approve(\\n address owner,\\n address spender,\\n uint256 amount\\n ) internal virtual {\\n require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n _allowances[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n /**\\n * @dev Updates `owner` s allowance for `spender` based on spent `amount`.\\n *\\n * Does not update the allowance amount in case of infinite allowance.\\n * Revert if not enough allowance is available.\\n *\\n * Might emit an {Approval} event.\\n */\\n function _spendAllowance(\\n address owner,\\n address spender,\\n uint256 amount\\n ) internal virtual {\\n uint256 currentAllowance = allowance(owner, spender);\\n if (currentAllowance != type(uint256).max) {\\n require(currentAllowance >= amount, \\\"ERC20: insufficient allowance\\\");\\n unchecked {\\n _approve(owner, spender, currentAllowance - amount);\\n }\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * will be transferred to `to`.\\n * - when `from` is zero, `amount` tokens will be minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {}\\n\\n /**\\n * @dev Hook that is called after any transfer of tokens. This includes\\n * minting and burning.\\n *\\n * Calling conditions:\\n *\\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n * has been transferred to `to`.\\n * - when `from` is zero, `amount` tokens have been minted for `to`.\\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\\n * - `from` and `to` are never both zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual {}\\n}\\n\"" + ], + [ + "return data size checking mechanism, s", + "ince\\n // " + ], + [ + "Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement", + "\\n * " + ], + [ + "not all ", + "leaves have been consum" + ], + [ + "bytes32[](", + "totalHashes);\\n uint256 leafPo" + ], + [ + ", \\\"MerkleProof: invalid multiproof", + "\\\");\\n\\n // The " + ], + [ + "(_packedOwnerships[", + "index]);\\n }\\n\\n /**\\n * @dev " + ], + [ + ";\\n }\\n _balances[to] += ", + "amount;\\n\\n emit Transfer" + ], + [ + "minted with ", + "ERC2309 exceeds the " + ], + [ + "/// @author: ", + "manifold.xyz" + ], + [ + "Calling this function ", + "outside of contract " + ], + [ + ".\\n */\\ninterface ERC721A__IERC721Receiver", + " {\\n function onERC721Received(\\n address operator,\\n address from,\\n uint256 tokenId,\\n bytes calldata data\\n ) external returns (bytes4);\\n}\\n\\n" + ], + [ + "packed = _packedAddressData[owner", + "];\\n uint256 aux" + ], + [ + "branches", + ") or an element from the\\n // " + ], + [ + "_packedOwnerships[index] == 0) {\\n ", + "_packedOwnerships[index] = _packedOwnershipOf(index);\\n }\\n }\\n\\n " + ], + [ + "(uint256 packed) private pure returns (TokenOwnership memory ownership", + ") {\\n ownership.addr = address(uint160(packed));\\n ownership.startTimestamp = uint64(" + ], + [ + "from `packed`.\\n */\\n function _unpackedOwnership", + "(uint256 packed) private pure returns (TokenOwnership memory ownership) {\\n ownership.addr = address(uint160(packed));\\n ownership.startTimestamp = uint64(" + ], + [ + " == 0; // and not burned.", + "\\n }\\n\\n /**\\n * @dev " + ], + [ + "BITPOS_AUX);\\n }\\n\\n /**\\n * Sets the ", + "auxiliary data for `owner`. (e.g. number of whitelist mint slots used).\\n * If there are multiple variables, please pack them into a uint64.\\n */\\n function _setAux(address owner, uint64 aux" + ], + [ + "call data (encoded using abi.encode or one of its ", + "variants" + ], + [ + "`\\n mapping(uint256 => uint256) private ", + "_packedOwnerships;\\n\\n // Mapping owner address to address data" + ], + [ + "\\\" to the ", + "next value to " + ], + [ + "bytes32 previousAdmin", + "Role = getRoleAdmin(role" + ], + [ + "), \\\"SafeERC20: ", + "ERC20 operation did not succeed" + ], + [ + "Packs ", + "ownership data into a single uint256" + ], + [ + "if (!isApprovedOrOwner", + ") revert TransferCallerNotOwnerNorApproved" + ], + [ + ";\\n _decimals = 18", + ";\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name" + ], + [ + "ConsecutiveTransfer} event", + " is only permissible " + ], + [ + "spendAllowance(account", + ", _msgSender(), " + ], + [ + ".\\n //\\n // Bits Layout:\\n // - [0..", + "63] `balance`\\n // - [64..127] `numberMinted" + ], + [ + "abi.decode(returndata, (bool)", + "), \\\"SafeERC20: ERC20 operation did not succeed" + ], + [ + "prizes", + "and" + ], + [ + "To use this library you can add a `", + "using SafeERC20 for IERC20;` statement to your contract" + ], + [ + "consuming and producing values on a queue", + ". The queue starts with the " + ], + [ + ":\\n // - ", + "a value from the \\\"main queue" + ], + [ + "`quantity", + "` to be below the " + ], + [ + "`nextInitialized` ", + "flag set if `" + ], + [ + "cosum", + "er contract" + ], + [ + "\\\".\\n ", + "bytes32[] memory hashes = new " + ], + [ + "\\\". If ", + "not all leaves have been consum" + ], + [ + "\\\"pointers", + "\\\" to the next value to " + ], + [ + "total of ", + "3.68" + ], + [ + "), eq(msgSender, ", + "approvedAddress" + ], + [ + "from rightmost dig", + "it to " + ], + [ + "msgSender := and(", + "msgSender" + ], + [ + "with verification of ", + "Merkle T" + ], + [ + "Mints `quantity` tokens and transfers them to `to`.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `quantity` must be greater than 0", + ".\\n *\\n * Emits a {Transfer} event for each mint.\\n */\\n function _mint" + ], + [ + "illcreate", + "andearn" + ], + [ + "`fromTokenId", + "` to `toTokenId" + ], + [ + "hashes on the ", + "branch from the " + ], + [ + "` cannot be set on ", + "an unintialized ownership slot" + ], + [ + " == totalHashes", + ", \\\"MerkleProof: invalid multiproof\\\");\\n\\n // The " + ], + [ + "`tokenId` has a ", + "maximum limit of 2**256" + ], + [ + "operating", + "costs" + ], + [ + "non-compliant with the ", + "ERC721 standard" + ], + [ + "proofs can be ", + "generated " + ], + [ + "proof[proof", + "Pos++];\\n hashes[i] = _" + ], + [ + "ing the tree up", + " from the leaves. The root is " + ], + [ + "using\\n // `", + "xxx[xxx" + ], + [ + "`owner | (", + "block.timestamp" + ], + [ + "For branchless ", + "setting of the `nextInitialized` " + ], + [ + "Balance exceeds ", + "wallet size" + ], + [ + "Emitted when tokens in ", + "`fromTokenId` to `toTokenId" + ], + [ + "each array. All ", + "accesses are done " + ], + [ + " overflows on the ", + "address data entries." + ], + [ + "equivalent to `approved", + "Address = _tokenApproval" + ], + [ + "ance, sub", + "stituting ERC721 " + ], + [ + ") {\\n // This function ", + "rebuil" + ], + [ + "consume in ", + "each array. All accesses are done " + ], + [ + "hash in the `hashes", + "` array should contain the " + ], + [ + "hash using two values", + ":\\n // - a value from the \\\"main queue" + ], + [ + "returned result is shifted ", + "into position" + ], + [ + "// The following is ", + "equivalent to `approvedAddress = _tokenApproval" + ], + [ + "} else if (leavesLen ", + "> 0) {\\n return leaves[0];\\n } else {\\n return " + ], + [ + "root`. For ", + "this, a `proof` must be " + ], + [ + "For a limit of ", + "5000, a " + ], + [ + "root of\\n // the ", + "merkle tree.\\n uint256 leavesLen" + ], + [ + "root hash by travers", + "ing the tree up from the leaves. The root is " + ], + [ + "BITMASK_ADDRESS = (1 << ", + "160" + ], + [ + "leaves and each ", + "pair of pre-images are assumed to be sorted" + ], + [ + "full ERC721 compli", + "ance, substituting ERC721 " + ], + [ + "\\n ) internal pure returns (bytes32 merkleRoot", + ") {\\n // This function rebuil" + ], + [ + "unrealistic due to the ", + "above check for " + ], + [ + "proofFlags.length;\\n\\n // Check ", + "proof validity" + ], + [ + "`\\n // - [128..191] `numberBurned", + "`\\n // - [192..255] `aux" + ], + [ + "`\\n // - [224] `burned", + "`\\n // - [225] `nextInitialized" + ], + [ + "in a packed ownership ", + "except the 24 bits for `" + ], + [ + "the\\n // `hashes", + "` array. At the " + ], + [ + "thus mim", + "icking a queue's \\\"pop" + ], + [ + "232..255] `", + "extraData" + ], + [ + "packOwnershipData(address owner, uint256 ", + "flags" + ], + [ + "uint24 extraData = uint24(", + "prevOwnershipPacked " + ], + [ + "ConsecutiveTransfer(uint256 indexed ", + "fromTokenId, uint256 toTokenId, address indexed from, address indexed to" + ], + [ + "uint256(_extraData(from, to, extraData", + ")) " + ], + [ + "BITPOS_START_TIMESTAMP) | ", + "flags" + ], + [ + "BITPOS_START_TIMESTAMP, timestamp()), ", + "flags" + ], + [ + "set the 24bit ", + "`extraData` field" + ], + [ + "communityt", + "reasurydao" + ], + [ + "try ERC721A__IERC721Receiver(to).onERC721Received", + "(_msgSenderERC721A(), from, tokenId, _data) returns (" + ], + [ + "totalHashes; i++) {\\n bytes32 a = ", + "leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];\\n bytes32 b = " + ], + [ + "\\\" (merging ", + "branches) or an element from the\\n // " + ], + [ + "hashes[totalHashes ", + "- 1" + ], + [ + "otherwise we\\n // ", + "get the next hash.\\n // - " + ], + [ + "BITPOS_AUX);\\n _packedAddressData[owner", + "] = packed" + ], + [ + "BITPOS_NEXT_INITIALIZED, eq(", + "quantity, 1" + ], + [ + "leaf to the root of the tree. ", + "Each\\n * pair of " + ], + [ + ".\\n uint256 private _burnCounter;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to ownership details\\n // An empty struct value does not necessarily mean the token is unowned", + ".\\n // " + ], + [ + ".\\n uint256 private _currentIndex;\\n\\n // The number of tokens burned", + ".\\n uint256 private _burnCounter;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to ownership details\\n // An empty struct value does not necessarily mean the token is unowned.\\n // " + ], + [ + "approvedAddress := sload(", + "approvedAddressSlot" + ], + [ + "end of the process, the last ", + "hash in the `hashes` array should contain the " + ], + [ + "xxxPos values are ", + "\\\"pointers\\\" to the next value to " + ], + [ + "hashPair(a, b);\\n }\\n\\n if (", + "totalHashes " + ], + [ + "`balance` and `numberMinted` have a ", + "maximum limit of 2**64." + ], + [ + "each step, we compute the next ", + "hash using two values:\\n // - a value from the \\\"main queue" + ], + [ + "(proof, proofFlags, leaves", + ") == root" + ], + [ + "These functions deal ", + "with verification of Merkle T" + ], + [ + "previousExtraData` - the ", + "value of `extraData` before " + ], + [ + "9e15 ", + "calls to " + ], + [ + "`proof` array.\\n for (uint256 i = 0; i < ", + "totalHashes; i++) {\\n bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];\\n bytes32 b = " + ], + [ + "increment the pointer, ", + "thus mimicking a queue's \\\"pop" + ], + [ + "s = 0;\\n uint256 proofPo", + "s = 0;\\n // At " + ], + [ + "s = 0;\\n uint256 hashPo", + "s = 0;\\n uint256 proofPos = 0;\\n // At " + ], + [ + "rebuilt by\\n // ", + "consuming and producing values on a queue. The queue starts with the " + ], + [ + "depending on the flag, either ", + "another " + ], + [ + "implementation for details.\\n //\\n // Bits Layout:\\n // - [0..", + "159] `addr`\\n // - [160..223] `startTimestamp" + ], + [ + "`\\n mapping(address => uint256) private _packedAddressData", + ";\\n\\n // Mapping from token ID to approved address.\\n mapping(uint256 => " + ], + [ + "intended for efficient minting ", + "only " + ], + [ + "`leaves` array, then ", + "goes onto " + ], + [ + "provided, containing\\n * sibling ", + "hashes on the branch from the " + ], + [ + "limit is to prevent", + " overflows on the address data entries." + ], + [ + "creation WILL ", + "make your contract" + ], + [ + "storage slot and value for the ", + "approved address " + ], + [ + ".\\n *\\n * To select a different value for {decimals}, use {_setupDecimals", + "}.\\n *\\n * All three of these values are immutable: they can only be set once during\\n * construction" + ], + [ + ".length;\\n uint256 totalHashes = ", + "proofFlags.length;\\n\\n // Check proof validity" + ], + [ + "string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev Returns the number of decimals used to get its user representation.\\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\\n *\\n * Tokens usually opt for a value of 18, imitating the relationship between\\n * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals", + "} is\\n * called.\\n *\\n * NOTE: This information is only used for _display_ purposes: it in\\n * no way affects any of the arithmetic of the contract, including\\n * {IERC20-balanceOf} and {IERC20-transfer}.\\n */\\n function decimals" + ], + [ + "Arbitrary data similar to `", + "startTimestamp` that can be set " + ], + [ + "MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` ", + "can be proved to be a part of a Merkle tree\\n * defined by `" + ], + [ + "is required to cause an overflow", + ", which is unrealistic" + ], + [ + "Intended to be overridden by the ", + "cosumer contract" + ], + [ + "It emits only one {", + "ConsecutiveTransfer} as defined " + ], + [ + "ed, we get the next leaf, ", + "otherwise we\\n // get the next hash.\\n // - " + ], + [ + "mask of the lower 160 bits for ", + "addresses" + ], + [ + "Pos++]`, which return the current value and ", + "increment the pointer, thus mimicking a queue's \\\"pop" + ], + [ + "}, initializes {decimals} with\\n * a default value of 18", + ".\\n *\\n * To select a different value for {decimals}, use {_setupDecimals}.\\n *\\n * All three of these values are immutable: they can only be set once during\\n * construction" + ], + [ + "ed during each token transfer to ", + "set the 24bit `extraData` field" + ], + [ + "bytes32[](totalHashes);\\n uint256 leafPo", + "s = 0;\\n uint256 hashPos = 0;\\n uint256 proofPos = 0;\\n // At " + ], + [ + "minted with ERC2309 exceeds the ", + "safety limit" + ], + [ + "Calling this function outside of contract ", + "creation WILL make your contract" + ], + [ + "`\\n mapping(uint256 => uint256) private _packedOwnerships;\\n\\n // Mapping owner address to address data", + ".\\n //\\n // Bits Layout:\\n // - [0..63] `balance`\\n // - [64..127] `numberMinted" + ], + [ + "ConsecutiveTransfer} event is only permissible ", + "during contract creation" + ], + [ + "`quantity` to be below the ", + "limit" + ], + [ + "`nextInitialized` flag set if `", + "quantity` equals 1" + ], + [ + "\\\".\\n bytes32[] memory hashes = new ", + "bytes32[](totalHashes);\\n uint256 leafPos = 0;\\n uint256 hashPos = 0;\\n uint256 proofPos = 0;\\n // At " + ], + [ + "\\\". If not all leaves have been consum", + "ed, we get the next leaf, otherwise we\\n // get the next hash.\\n // - " + ], + [ + "total of 3.68", + "9e15 calls to " + ], + [ + " == totalHashes, \\\"MerkleProof: invalid multiproof\\\");\\n\\n // The ", + "xxxPos values are \\\"pointers\\\" to the next value to " + ], + [ + "proof[proofPos++];\\n hashes[i] = _", + "hashPair(a, b);\\n }\\n\\n if (totalHashes " + ], + [ + "using\\n // `xxx[xxx", + "Pos++]`, which return the current value and increment the pointer, thus mimicking a queue's \\\"pop" + ], + [ + "For branchless setting of the `nextInitialized` ", + "flag" + ], + [ + "consume in each array. All accesses are done ", + "using\\n // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \\\"pop" + ], + [ + "} else if (leavesLen > 0) {\\n return leaves[0];\\n } else {\\n return ", + "proof[0];\\n " + ], + [ + "root`. For this, a `proof` must be ", + "provided, containing\\n * sibling hashes on the branch from the " + ], + [ + "For a limit of 5000, a ", + "total of 3.689e15 calls to " + ], + [ + "root of\\n // the merkle tree.\\n uint256 leavesLen", + " = leaves" + ], + [ + "root hash by traversing the tree up from the leaves. The root is ", + "rebuilt by\\n // consuming and producing values on a queue. The queue starts with the " + ], + [ + "leaves and each pair of pre-images are assumed to be sorted", + ".\\n */\\n function verify" + ], + [ + "full ERC721 compliance, substituting ERC721 ", + "{Transfer} event(s) with the ERC2309" + ], + [ + "unrealistic due to the above check for ", + "`quantity` to be below the limit" + ], + [ + "`\\n // - [128..191] `numberBurned`\\n // - [192..255] `aux", + "`\\n mapping(address => uint256) private _packedAddressData;\\n\\n // Mapping from token ID to approved address.\\n mapping(uint256 => " + ], + [ + "in a packed ownership except the 24 bits for `", + "extraData" + ], + [ + "the\\n // `hashes` array. At the ", + "end of the process, the last hash in the `hashes` array should contain the " + ], + [ + "\\\" (merging branches) or an element from the\\n // ", + "`proof` array.\\n for (uint256 i = 0; i < totalHashes; i++) {\\n bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];\\n bytes32 b = " + ], + [ + "leaf to the root of the tree. Each\\n * pair of ", + "leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify" + ], + [ + "each step, we compute the next hash using two values:\\n // - a value from the \\\"main queue", + "\\\". If not all leaves have been consumed, we get the next leaf, otherwise we\\n // get the next hash.\\n // - " + ], + [ + "previousExtraData` - the value of `extraData` before ", + "transfer" + ], + [ + "implementation for details.\\n //\\n // Bits Layout:\\n // - [0..159] `addr`\\n // - [160..223] `startTimestamp", + "`\\n // - [224] `burned`\\n // - [225] `nextInitialized" + ], + [ + "`leaves` array, then goes onto ", + "the\\n // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the " + ], + [ + ".length;\\n uint256 totalHashes = proofFlags.length;\\n\\n // Check proof validity", + ".\\n require(leavesLen + proof" + ], + [ + "MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `", + "root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the " + ], + [ + "`\\n mapping(uint256 => uint256) private _packedOwnerships;\\n\\n // Mapping owner address to address data.\\n //\\n // Bits Layout:\\n // - [0..63] `balance`\\n // - [64..127] `numberMinted", + "`\\n // - [128..191] `numberBurned`\\n // - [192..255] `aux`\\n mapping(address => uint256) private _packedAddressData;\\n\\n // Mapping from token ID to approved address.\\n mapping(uint256 => " + ], + [ + "\\\".\\n bytes32[] memory hashes = new bytes32[](totalHashes);\\n uint256 leafPos = 0;\\n uint256 hashPos = 0;\\n uint256 proofPos = 0;\\n // At ", + "each step, we compute the next hash using two values:\\n // - a value from the \\\"main queue\\\". If not all leaves have been consumed, we get the next leaf, otherwise we\\n // get the next hash.\\n // - " + ], + [ + " == totalHashes, \\\"MerkleProof: invalid multiproof\\\");\\n\\n // The xxxPos values are \\\"pointers\\\" to the next value to ", + "consume in each array. All accesses are done using\\n // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \\\"pop" + ], + [ + "root hash by traversing the tree up from the leaves. The root is rebuilt by\\n // consuming and producing values on a queue. The queue starts with the ", + "`leaves` array, then goes onto the\\n // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the " + ], + [ + "\\\" (merging branches) or an element from the\\n // `proof` array.\\n for (uint256 i = 0; i < totalHashes; i++) {\\n bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];\\n bytes32 b = ", + "proofFlag" + ], + [ + "MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the ", + "leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify" + ], + [ + "\\\".\\n bytes32[] memory hashes = new bytes32[](totalHashes);\\n uint256 leafPos = 0;\\n uint256 hashPos = 0;\\n uint256 proofPos = 0;\\n // At each step, we compute the next hash using two values:\\n // - a value from the \\\"main queue\\\". If not all leaves have been consumed, we get the next leaf, otherwise we\\n // get the next hash.\\n // - ", + "depending on the flag, either another " + ], + [ + " == totalHashes, \\\"MerkleProof: invalid multiproof\\\");\\n\\n // The xxxPos values are \\\"pointers\\\" to the next value to consume in each array. All accesses are done using\\n // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \\\"pop", + "\\\".\\n bytes32[] memory hashes = new bytes32[](totalHashes);\\n uint256 leafPos = 0;\\n uint256 hashPos = 0;\\n uint256 proofPos = 0;\\n // At each step, we compute the next hash using two values:\\n // - a value from the \\\"main queue\\\". If not all leaves have been consumed, we get the next leaf, otherwise we\\n // get the next hash.\\n // - depending on the flag, either another " + ], + [ + "root hash by traversing the tree up from the leaves. The root is rebuilt by\\n // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the\\n // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the ", + "root of\\n // the merkle tree.\\n uint256 leavesLen = leaves" + ], + [ + "'", + ", v" + ], + [ + "(", + "##" + ], + [ + "(", + "2^" + ], + [ + "(", + "startTokenId, " + ], + [ + ")", + "\\n function " + ], + [ + ")", + "`,\\n // " + ], + [ + ",", + "\\n * " + ], + [ + ".", + "\\n /// @param _" + ], + [ + ".", + "\\n @member " + ], + [ + "0", + "38" + ], + [ + "2", + "ee" + ], + [ + "2", + ") {\\n value /= 10**" + ], + [ + "2", + ";\\n }\\n if (value >= 10**" + ], + [ + "3", + "D" + ], + [ + "3", + "E" + ], + [ + "4", + ") {\\n value /= 10**" + ], + [ + "7", + "._\\r\\n */\\r\\n function " + ], + [ + "8", + "._\\n */\\n function " + ], + [ + "8", + ") {\\n value /= 10**" + ], + [ + ":", + " " + ], + [ + "B", + "R" + ], + [ + "B", + "reedingEvent" + ], + [ + "F", + "0" + ], + [ + "G", + "ov" + ], + [ + "I", + "SeaDrop(seaDropImpl" + ], + [ + "K", + "IND" + ], + [ + "N", + "ON" + ], + [ + "S", + "E" + ], + [ + "S", + "ince" + ], + [ + "W", + "e" + ], + [ + "W", + "IS" + ], + [ + "Y", + "Y" + ], + [ + "_", + "mem" + ], + [ + "_", + "Enabled" + ], + [ + "_", + "WETH" + ], + [ + "_", + "vault" + ], + [ + "_", + "blacklist" + ], + [ + "`", + "keccak256(bytes(\\\"" + ], + [ + "f", + "y " + ], + [ + "s", + "," + ], + [ + "y", + "m" + ], + [ + "\\n ", + "uint24 extraData" + ], + [ + "\\n ", + ") {\\n return retval == " + ], + [ + "in", + "k" + ], + [ + ", ", + "input" + ], + [ + "un", + "block" + ], + [ + "\\n * ", + "non-compliant with the ERC721 standard" + ], + [ + "or", + "(owner, " + ], + [ + ") ", + "<< _" + ], + [ + ") ", + "in case of unsuccessful call or if target was not a contract" + ], + [ + "address", + ") public " + ], + [ + "ol", + "o" + ], + [ + "the ", + "new " + ], + [ + "am", + "ask" + ], + [ + "ing", + ":" + ], + [ + "\\n ", + "bytes4 retval" + ], + [ + "is", + "Contract " + ], + [ + "co", + "ins" + ], + [ + "amount", + " * " + ], + [ + "\\\"", + "v" + ], + [ + "\\\"", + "1\\\"" + ], + [ + "ver", + "sal" + ], + [ + "// ", + "`tokenId" + ], + [ + "uint256 ", + "packed = _packedOwnerships[" + ], + [ + "ri", + "ght to " + ], + [ + "of ", + "two signed " + ], + [ + "bool", + ");\\n function " + ], + [ + "su", + "ffic" + ], + [ + "or ", + "of " + ], + [ + "or ", + "not" + ], + [ + "or ", + "using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {" + ], + [ + "er ", + "= _" + ], + [ + "transfer", + "AndCall" + ], + [ + ".\\n *\\n * ", + "To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _" + ], + [ + "st", + "age" + ], + [ + " = ", + "keccak256(bytes(version" + ], + [ + "ch", + "iru" + ], + [ + ".\\n */\\n function ", + "un" + ], + [ + ".\\n */\\n function ", + "mint" + ], + [ + ",\\n ", + "string calldata " + ], + [ + "external", + "/" + ], + [ + ") {\\n ", + "(" + ], + [ + "data", + ".\\n * The " + ], + [ + "32", + ") {\\n value /= 10**" + ], + [ + "\\n ", + "let " + ], + [ + "set", + "s of " + ], + [ + "ay", + "l" + ], + [ + "Ma", + "pping" + ], + [ + "add", + "Bots" + ], + [ + "msgSender", + "\\n ) private pure returns (" + ], + [ + "approve", + "AndCall" + ], + [ + "only", + "Governance" + ], + [ + "For", + "Liquidity" + ], + [ + "16", + ") {\\n value /= 10**" + ], + [ + "Tokens", + "[" + ], + [ + "low", + "n" + ], + [ + "current", + "Supply" + ], + [ + "on ", + "buy" + ], + [ + "operator", + " != " + ], + [ + "name", + "Hash" + ], + [ + "name", + "` and `" + ], + [ + ");\\n\\n ", + "unchecked {\\n if (" + ], + [ + "] ", + "> " + ], + [ + ";\\n\\n ", + "/*//////////////////////////////////////////////////////////////\\n " + ], + [ + "Mint", + "Price" + ], + [ + ").", + "update" + ], + [ + "target", + "Address" + ], + [ + " ", + "packed = _packedOwnerships[--" + ], + [ + "for", + "(uint " + ], + [ + "\\n ", + "//" + ], + [ + "\\n ", + "}\\n\\n function " + ], + [ + "Si", + "z" + ], + [ + ") {\\n ", + "a = (a * ONE_20) / " + ], + [ + "10", + "_000" + ], + [ + "\\n // ", + "`tokenId` has a maximum limit of 2**256" + ], + [ + "mul", + "t" + ], + [ + "\\\");\\n ", + "(bool success, bytes memory returndata) = target.call{value: value}" + ], + [ + "implement", + "s an " + ], + [ + "`.", + "\\n " + ], + [ + "iz", + "ed by " + ], + [ + "(\\n address ", + "approvedAddress" + ], + [ + ".\\n */\\n function _", + "nextExtraData" + ], + [ + ".\\n */\\n function _", + "nextInitializedFlag(uint256 quantity" + ], + [ + ".\\n */\\n function _", + "packOwnershipData(address owner, uint256 flags" + ], + [ + "buy", + "Back" + ], + [ + ";\\n ", + "sum += x" + ], + [ + "functionCall", + "} to " + ], + [ + "tic", + "al " + ], + [ + ");\\n\\n /**\\n * @dev ", + "Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account" + ], + [ + "leg", + "end" + ], + [ + "\\n // ", + "For a limit of 5000, a total of 3.689e15 calls to " + ], + [ + "0, ", + "// Start " + ], + [ + " != ", + "0, errorMessage" + ], + [ + ".\\n * ", + "Intended to be overridden by the cosumer contract" + ], + [ + "balance ", + "of the " + ], + [ + "in the ", + "low-level " + ], + [ + "in the ", + "map" + ], + [ + "64", + ") {\\n value /= 10**" + ], + [ + "interface ", + "IUniswapV2Factory " + ], + [ + "Pool", + "Tokens" + ], + [ + "cent", + "iv" + ], + [ + ");\\n return ", + "uint256(_extraData(from, to, extraData)) " + ], + [ + ")\\\"", + ")," + ], + [ + ") external", + ";\\n\\n function " + ], + [ + "Metadata", + "URI" + ], + [ + "\"// SPDX-License-Identifier: MIT\\n// ", + "Copyright " + ], + [ + "uint256) {\\n ", + "uint24 extraData = uint24(prevOwnershipPacked " + ], + [ + "uint amount", + "0Out" + ], + [ + ".\\n ", + "assembly {\\n // " + ], + [ + "uniswapV2Pair", + " = IUniswapV2Factory" + ], + [ + "Res", + "et" + ], + [ + "(tokenId", + ");\\n }\\n\\n /**\\n * @dev " + ], + [ + "[] memory ", + "proofFlags" + ], + [ + "s are ", + "sequ" + ], + [ + "(\\n address from,\\n address to,\\n uint256 ", + "prevOwnershipPacked" + ], + [ + ");\\r\\n ", + "}\\r\\n " + ], + [ + "reward", + "Tracker" + ], + [ + ".\\n *\\n * ", + "_Available since v3.4._" + ], + [ + ";\\n ", + "do {\\n " + ], + [ + ";\\n\\n ", + "num = (num * z_squared" + ], + [ + ";\\n\\n ", + "term = ((term * x) / ONE_20) / " + ], + [ + ";\\n }\\n ", + "_balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount" + ], + [ + ");\\n\\n /**\\n * @dev Returns the ", + "admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {" + ], + [ + "that is ", + "used " + ], + [ + "was ", + "designed to be " + ], + [ + "s for ", + "success " + ], + [ + "admin", + "_" + ], + [ + ")\\n ", + "internal" + ], + [ + "Non", + "blocking" + ], + [ + "Base", + "RewardPool" + ], + [ + "gu", + "ardian" + ], + [ + ".\\n */\\n event ", + "ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to" + ], + [ + "Upgrade", + "State" + ], + [ + "() external ", + "returns (" + ], + [ + "price", + "_" + ], + [ + "amountIn", + "Wei" + ], + [ + "also ", + "assert" + ], + [ + ");\\n\\n // ", + "The nested ifs save around 20+ gas over a compound boolean condition" + ], + [ + "Lock", + "er" + ], + [ + "(bytes32 ", + "poolId" + ], + [ + "Minter", + "Removed" + ], + [ + "\"contracts/", + "lib/" + ], + [ + "s.\\n *\\n * ", + "_Available since v4.5._" + ], + [ + "\\n * @param ", + "token The token targeted by the call" + ], + [ + ", which ", + "verifies " + ], + [ + "interfaces/", + "IERC" + ], + [ + "cannot ", + "send tokens " + ], + [ + "spend", + "ing " + ], + [ + "erc", + "4626" + ], + [ + "restr", + "ict" + ], + [ + "function is ", + "intended for efficient minting only " + ], + [ + "leaf", + "Pos" + ], + [ + "```", + "\\n */\\n function _" + ], + [ + "Stand", + "ardiz" + ], + [ + ".\\n */\\n error ", + "OwnershipNotInitializedForExtraData" + ], + [ + "extraData", + "Casted;\\n // Cast " + ], + [ + "delegate", + "AndReturn" + ], + [ + "scal", + "ar" + ], + [ + ") external;\\n\\n /**\\n * @dev ", + "Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account" + ], + [ + ") external;\\n\\n /**\\n * @dev ", + "Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account" + ], + [ + "drop", + "URI" + ], + [ + "rAmount", + ", vestingRound" + ], + [ + "10**", + "result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base " + ], + [ + "10**", + "64) {\\n value /= 10**" + ], + [ + "check ", + "isContract " + ], + [ + "(address target, bytes memory data", + ") internal returns (bytes memory) {\\n return functionCallWithValue(target, data" + ], + [ + "_exists", + "(uint256 tokenId" + ], + [ + "\\n */\\ninterface ", + "IERC2981" + ], + [ + "5d", + "6" + ], + [ + "\\n * {", + "ConsecutiveTransfer} event is only permissible during contract creation" + ], + [ + "See ", + "`" + ], + [ + ", 0", + ", \\\"Address: low-level " + ], + [ + "(data", + ", \\\"SafeERC20: " + ], + [ + "royalty ", + "is owed and to whom" + ], + [ + "request", + "Random" + ], + [ + "as an ", + "immutable " + ], + [ + ") external view returns (bool", + ");\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {" + ], + [ + "uint24", + ") {}\\n\\n /**\\n * @dev " + ], + [ + ".sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../", + "Strings.sol\\\";\\n\\n/**\\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\\n *\\n * These functions can be used to verify that a message was signed by the holder\\n * of the private keys of a given address.\\n */\\nlibrary ECDSA {\\n enum RecoverError {\\n NoError,\\n InvalidSignature,\\n InvalidSignatureLength,\\n InvalidSignatureS,\\n InvalidSignatureV" + ], + [ + ".\\n */\\n constructor(", + ") {\\n _paused = false" + ], + [ + ").interfaceId ", + "||" + ], + [ + "Shares", + "Out" + ], + [ + "Shares", + "ToRedeem" + ], + [ + ";\\n // ", + "Arbitrary data similar to `startTimestamp` that can be set " + ], + [ + "Cach", + "ed" + ], + [ + ".\\n *\\n * See {", + "_mint}" + ], + [ + ".\\n *\\n * _Available since v4.", + "8._\\n */\\n function " + ], + [ + "[_", + "pid" + ], + [ + "\\n // ", + "There will always be an " + ], + [ + "set of ", + "addresses " + ], + [ + "Role(role, account", + ");\\n _" + ], + [ + "(\\n address owner,\\n address ", + "operator,\\n bool approved" + ], + [ + "();\\n\\n /**\\n * The ", + "`extraData" + ], + [ + "();\\n\\n /**\\n * The ", + "`quantity` " + ], + [ + "`.\\n *\\n * This ", + "function is intended for efficient minting only " + ], + [ + "));\\n }\\n\\n /**\\n * @dev ", + "Return the entire set in an array\\n *\\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\\n */\\n function values(" + ], + [ + "perform ", + "this call" + ], + [ + "in\\n * ", + "[ERC2309](https://eips.ethereum.org/EIPS/eip-2309" + ], + [ + "bit", + "map._" + ], + [ + ".\\n */\\nlibrary ", + "MerkleProof {\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify" + ], + [ + "`.\\n ", + "++_packedAddressData[to]; // Updates: `balance += 1`." + ], + [ + "Ptr", + " := add(" + ], + [ + "Revoked", + "} event.\\n */\\n function " + ], + [ + ") return (false, 0", + ");\\r\\n " + ], + [ + "meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (", + "address payable) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes memory" + ], + [ + "\\\");\\n ", + "}\\n return returndata;\\n } else {" + ], + [ + ") {\\n // ", + "The nested ifs save around 20+ gas over a compound boolean condition" + ], + [ + "Renounc", + "ed" + ], + [ + "allPair", + "s(" + ], + [ + "SafeERC20: ", + "approve from non-zero to non-zero allowance" + ], + [ + "here", + ", " + ], + [ + "setFeeTo", + "(address" + ], + [ + "for more ", + "details" + ], + [ + "sequ", + "ential " + ], + [ + "](", + "https://eips.ethereum.org/EIPS/eip-165" + ], + [ + "gas.\\n */\\n function ", + "supportsInterface(bytes4 interfaceId) public view virtual " + ], + [ + "\\\\x19", + "\\\\x01" + ], + [ + "UL", + "L" + ], + [ + ";\\n }\\n if (value >= 10**", + "2) {\\n value /= 10**" + ], + [ + ";\\n }\\n if (value >= 10**", + "4) {\\n value /= 10**" + ], + [ + ";\\n }\\n if (value >= 10**", + "8) {\\n value /= 10**" + ], + [ + ";\\n }\\n if (value >= 10**", + "32) {\\n value /= 10**" + ], + [ + ";\\n }\\n if (value >= 10**", + "16) {\\n value /= 10**" + ], + [ + "BITPOS_EXTRA_DATA", + ");\\n return uint256(_extraData(from, to, extraData)) " + ], + [ + ".\\n *\\n * `", + "previousExtraData` - the value of `extraData` before transfer" + ], + [ + "SwapAndLiquify", + "Enabled" + ], + [ + "s).\\n *\\n * ", + "Calling this function outside of contract creation WILL make your contract" + ], + [ + ", // ", + "Signature" + ], + [ + "ConsecutiveTransfer", + "} event.\\n */\\n function _mint" + ], + [ + "ConsecutiveTransfer", + "(startTokenId, " + ], + [ + "11/", + "solmate/blob/main/src/" + ], + [ + "123456789abcdef", + "\"" + ], + [ + ";\\n\\n // The bit position of `", + "extraData" + ], + [ + "May ", + "not " + ], + [ + "),\\n * ", + "instead of a sequence of {Transfer} event(" + ], + [ + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n ", + "_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, \\\"ERC20: decreased allowance below zero\\\"));\\n return true;\\n }\\n\\n /**\\n * @dev " + ], + [ + ")) private _allowances;\\n\\n uint256 private _totalSupply;\\n\\n string private _name;\\n string private _symbol", + ";\\n uint8 private _decimals" + ], + [ + "Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll", + "}.\\n */\\n function isApprovedForAll(address owner, address operator" + ], + [ + ".sol\\\";\\n\\n/**\\n * @dev Interface for the ", + "NFT Royalty Standard" + ], + [ + "off-", + "chain" + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role", + ".\\n *\\n * May emit a {Role" + ], + [ + "(to, quantity", + ");\\n\\n unchecked {\\n if (" + ], + [ + ",\\n bytes memory returndata,\\n string memory errorMessage\\n ", + ") internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only " + ], + [ + "map._", + "indexes[" + ], + [ + "0, // ", + "End " + ], + [ + "BITMASK_NEXT_INITIALIZED", + ") | _nextExtraData" + ], + [ + "using the provided one", + ") in case of unsuccessful call or if target was not a contract" + ], + [ + "s `quantity` tokens and transfers them to `to", + "`.\\n *\\n * This function is intended for efficient minting only " + ], + [ + "index of the ", + "'0' " + ], + [ + " _nextExtraData", + "(from, to, prevOwnershipPacked" + ], + [ + "\\r\\n\\t", + "function " + ], + [ + "ckpt", + "s[" + ], + [ + "addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n ", + "uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(" + ], + [ + "\"TOKEN: ", + "Balance exceeds wallet size" + ], + [ + " as ", + "possible " + ], + [ + "BITPOS_NEXT_INITIALIZED", + "`.\\n result := " + ], + [ + "data is ", + "optional" + ], + [ + "-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory", + ") {\\n (bool success, bytes memory returndata) = target.staticcall" + ], + [ + ");\\n }\\n }\\n\\n function _", + "revert(bytes memory returndata" + ], + [ + "(IERC20 token", + ", bytes memory data" + ], + [ + "low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason ", + "or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {" + ], + [ + "setFeeToSetter", + "(address" + ], + [ + "index < ", + "end);\\n // Reentrancy protection" + ], + [ + "target address ", + "contains contract " + ], + [ + "token.allowance(address(this), spender", + ") == 0" + ], + [ + "IDex", + "Factory" + ], + [ + "`extraData", + "` with assembly to avoid redundant masking.\\n assembly {\\n " + ], + [ + ";\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\\n * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\\n * by default", + ", it can be " + ], + [ + ".\\n *\\n * Emits a {", + "ConsecutiveTransfer} event.\\n */\\n function _mint" + ], + [ + "approvedAddressSlot, address approvedAddress", + ")\\n {\\n " + ], + [ + "`.\\n result := ", + "or(" + ], + [ + "` to the lower 160 bits, in case the upper bits somehow aren't clean.\\n ", + "msgSender := and(msgSender" + ], + [ + "validat", + "e the " + ], + [ + "`.\\n _packedAddressData", + "[from] += " + ], + [ + ", address[] calldata path, address to, uint deadline", + ")\\n external\\n returns (" + ], + [ + ", address[] calldata path, address to, uint deadline", + ")\\n external\\n payable\\n returns (" + ], + [ + "address(0xdead", + "), true" + ], + [ + "(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage", + ");\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or " + ], + [ + "(address,address,", + "uint256)\\\"))" + ], + [ + "Type ", + "== " + ], + [ + "\\n view", + "\\n " + ], + [ + "];\\n if (", + "packed " + ], + [ + ") | (", + "extraDataCasted " + ], + [ + "32;\\n result += 32", + ";\\n }\\n if (value >= 10**16) {\\n value /= 10**" + ], + [ + "64;\\n result += 64", + ";\\n }\\n if (value >= 10**32) {\\n value /= 10**" + ], + [ + "(\\n address sender,\\n address recipient,\\n uint256 amount\\n ", + ") internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Call", + "ed during each token transfer to set the 24bit `extraData` field" + ], + [ + ",\\n bytes32 root", + ",\\n bytes32[] memory leaves" + ], + [ + "ASCII ", + "index of the '0' " + ], + [ + ".\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `quantity` must be greater than 0", + ".\\n *\\n * Emits a {ConsecutiveTransfer} event.\\n */\\n function _mint" + ], + [ + ");\\n\\n // Clear approvals from the previous owner\\n ", + "_approve(address(0), " + ], + [ + "_TRANSFER_EVENT_SIGNATURE", + ", // Signature" + ], + [ + "Indic", + "ates " + ], + [ + "10, following the selected rounding direction", + ", of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log256(value);\\n return result + (rounding == Rounding.Up && 1 << (" + ], + [ + "creator ", + "payout " + ], + [ + "\\n ) private view returns (", + "uint256) {\\n uint24 extraData = uint24(prevOwnershipPacked " + ], + [ + "ERC2309QuantityExceedsLimit", + "();\\n\\n /**\\n * The `extraData" + ], + [ + "_EXTRA_DATA_COMPLEMENT", + ") | (extraDataCasted " + ], + [ + "_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role", + ") external view returns (bytes32" + ], + [ + "2;\\n result += ", + "2;\\n }\\n if (value >= 10**" + ], + [ + "Glob", + "als" + ], + [ + ");\\n\\n /**\\n * @dev Revert with an error ", + "if the " + ], + [ + "frozen", + "Account" + ], + [ + "fraction", + " of the " + ], + [ + ",\\n bool", + "[] memory proofFlags" + ], + [ + "during contract ", + "creation.\\n *\\n * " + ], + [ + "address signer = ECDSA.recover", + "(digest" + ], + [ + "startTokenId + quantity", + ";\\n }\\n _afterTokenTransfers(address(0), to, startTokenId, quantity" + ], + [ + "COL", + "LATERAL" + ], + [ + ";\\n\\n // Mask of all 256 bits ", + "in a packed ownership except the 24 bits for `extraData" + ], + [ + "AccessControl-", + "_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account" + ], + [ + "AccessControl-", + "_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) external view returns (bytes32" + ], + [ + "The divisor cannot be zero", + ".\\r\\n */\\r\\n function " + ], + [ + "zro", + "PaymentAddress" + ], + [ + "do {\\n ", + "emit Transfer(address(0), to, updatedIndex" + ], + [ + "(\\n bytes32[] memory proof", + ",\\n bool[] memory proofFlags" + ], + [ + ") - 1;\\n\\n // The ", + "maximum `quantity` that can be minted " + ], + [ + ") - 1;\\n\\n // The ", + "mask of the lower 160 bits for addresses" + ], + [ + "Casted;\\n // Cast ", + "`aux" + ], + [ + "\\\",\\n Strings.", + "toHexString" + ], + [ + "\\n _revert(returndata, errorMessage", + ");\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a " + ], + [ + "\\n _revert(returndata, errorMessage", + ");\\n }\\n }\\n\\n function _revert(bytes memory returndata" + ], + [ + ",\\n bytes32[] memory leaves", + "\\n ) internal pure returns (bytes32 merkleRoot) {\\n // This function rebuil" + ], + [ + "format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/", + "\\n */\\n function _checkRole(bytes32 role, address account" + ], + [ + "format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/", + "\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _check" + ], + [ + "` with assembly to avoid redundant masking.\\n assembly {\\n ", + "auxCasted := aux" + ], + [ + ",\\n bytes memory _data\\n ) internal virtual {\\n _mint", + "(to, tokenId);\\n require(\\n _checkOnERC721Received" + ], + [ + ".\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, `tokenId` will be burned by `from`.\\n * - `from` and `to` are never both zero.\\n */\\n function _", + "extraData(\\n address from,\\n address to,\\n uint24 previousExtraData" + ], + [ + "path[1] = ", + "uniswapV2Router.WETH" + ], + [ + "Project ", + "ID" + ], + [ + "toMasked, ", + "// " + ], + [ + "how much ", + "royalty is owed and to whom" + ], + [ + ") external view returns (address pair", + ");\\n function " + ], + [ + "(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes", + "-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.staticcall" + ], + [ + "Abstr", + "act" + ], + [ + ": amount exceeds 96", + " bits\"" + ], + [ + ", string memory errorMessage) private pure ", + "{\\n // Look for revert reason and bubble it up if present\\n if (" + ], + [ + ".sol\\\";\\n\\nimport {", + " " + ], + [ + "EIP712 ", + "message " + ], + [ + "returndata.length > 0) {\\n // ", + "The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n " + ], + [ + "(address _from", + ", address _to" + ], + [ + "IERC721Receiver-onERC721Received}, which is called for each safe transfer.\\n * - `quantity` must be greater than 0", + ".\\n *\\n * See {_mint}" + ], + [ + "Return ", + "data is optional" + ], + [ + "`account`.\\n *\\n * Internal function without access restriction", + ".\\n *\\n * May emit a {Role" + ], + [ + ";\\n }", + "\\n " + ], + [ + "start time of ownership with minimal overhead for tokenomics.\\n uint64 startTimestamp;\\n // Whether the token has been burned.\\n bool burned", + ";\\n // Arbitrary data similar to `startTimestamp` that can be set " + ], + [ + "_balances[sender] = senderBalance - amount", + ";\\n }\\n _balances[recipient] += amount;\\n\\n emit Transfer(sender, recipient, amount" + ], + [ + "trustedRemote", + "Lookup" + ], + [ + "cannot exceed 2**256 - 1 (max value of uint256).\\n */\\ncontract ERC721A", + " is IERC721A" + ], + [ + "(\\n uint256 a,\\n uint256 b,\\n string memory errorMessage\\n ) internal pure returns (uint256) {\\n unchecked {\\n ", + "require(b > 0, errorMessage);\\n return " + ], + [ + "\\n unchecked {\\n return _currentIndex - ", + "_startTokenId();\\n }\\n }\\n\\n /**\\n * @dev Returns the total number of tokens burned.\\n */\\n function _totalBurned(" + ], + [ + "data[", + "bucket" + ], + [ + ";\\n uint256 ", + "index = end - quantity" + ], + [ + "(sender, recipient, amount);\\n _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, \\\"ERC20: transfer amount exceeds allowance\\\")", + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)" + ], + [ + "startTokenId() <= tokenId ", + "&&\\n " + ], + [ + ".\\n */\\n error Mint", + "ERC2309QuantityExceedsLimit();\\n\\n /**\\n * The `extraData" + ], + [ + "\\n // This ", + "limit is to prevent overflows on the address data entries." + ], + [ + "WA", + "RE" + ], + [ + " > 0) {\\r\\n ", + "value >>= " + ], + [ + ");\\n _roles[role].adminRole = adminRole", + ";\\n emit RoleAdminChanged(role, previousAdminRole, adminRole" + ], + [ + "16;\\n result += 16", + ";\\n }\\n if (value >= 10**8) {\\n value /= 10**" + ], + [ + "4;\\n result += 4", + ";\\n }\\n if (value >= 10**2) {\\n value /= 10**" + ], + [ + "8;\\n result += 8", + ";\\n }\\n if (value >= 10**4) {\\n value /= 10**" + ], + [ + "1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && ", + "10**result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base " + ], + [ + ") internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> 2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= ", + "10**64) {\\n value /= 10**" + ], + [ + "\"//SPDX-License-Identifier: ", + "MIT" + ], + [ + "`newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {", + "AccessControl-_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account" + ], + [ + ", address(0), ", + "to" + ], + [ + "(address pair, bool ", + "value" + ], + [ + "Role(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n ", + "bytes32 previousAdminRole = getRoleAdmin(role" + ], + [ + "return\\n _", + "startTokenId() <= tokenId &&\\n " + ], + [ + "Fic", + "tiveReserve" + ], + [ + "https://forum.", + "openzeppelin.com/" + ], + [ + "Modifi", + "ed from " + ], + [ + "_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + ", + "addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(" + ], + [ + "(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer", + "(sender, recipient, amount);\\n _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, \\\"ERC20: transfer amount exceeds allowance\\\"));\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)" + ], + [ + "Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size", + ";\\n assembly {\\n size := extcodesize(account)\\n }\\n return size > 0" + ], + [ + ";\\n seriesSum += term", + ";\\n\\n term = ((term * x) / ONE_20) / " + ], + [ + "ERC721Receiver interface.\\n */\\n error TransferToNonERC721ReceiverImplementer();\\n\\n /**\\n * Cannot transfer to the zero address.\\n */\\n error TransferToZeroAddress();\\n\\n /**\\n * The token does not exist.\\n */\\n error URIQueryForNonexistentToken", + "();\\n\\n /**\\n * The `quantity` " + ], + [ + "end, ", + "str" + ], + [ + "transmissions", + "11/solmate/blob/main/src/" + ], + [ + "Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer", + "(sender, recipient, amount);\\n\\n _balances[sender] = _balances[sender].sub(amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[recipient] = _balances[recipient].add(amount);\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` " + ], + [ + "uint256 end", + " = _currentIndex" + ], + [ + "signed 64.64", + "-bit " + ], + [ + "bool isApprovedOrOwner = (", + "_msgSender() == " + ], + [ + "return packed", + ";\\n }\\n " + ], + [ + "utils/Context.sol\\\";\\nimport \\\"../", + "utils/Strings.sol\\\";\\nimport \\\"../" + ], + [ + "Mask ", + "`to" + ], + [ + ");\\n\\n if (approvalCheck", + ") {\\n // The nested ifs save around 20+ gas over a compound boolean condition" + ], + [ + "\\n ) internal view virtual returns (", + "uint24) {}\\n\\n /**\\n * @dev " + ], + [ + "code and ", + "also assert" + ], + [ + "isContract(target), \\\"Address: call to non-contract", + "\\\");\\n }\\n return returndata;\\n } else {" + ], + [ + "BITPOS_NUMBER_BURNED;", + "`.\\n _packedAddressData[from] += " + ], + [ + "BITMASK_NEXT_INITIALIZED = 1 << 225", + ";\\n\\n // The bit position of `extraData" + ], + [ + "' and ", + "'" + ], + [ + "return _currentIndex - ", + "_burnCounter - _startTokenId();\\n }\\n }\\n\\n /**\\n * @dev Returns the total amount of tokens minted in the contract.\\n */\\n function _totalMinted(" + ], + [ + "\\n require(", + "isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {" + ], + [ + "),\\n \\\" is missing role ", + "\\\",\\n Strings." + ], + [ + "We need to perform a low level call here, to bypass ", + "Solidity's " + ], + [ + "--_packedAddressData[from]; // Updates: `balance -= 1", + "`.\\n ++_packedAddressData[to]; // Updates: `balance += 1`." + ], + [ + "setExtraData", + "At(uint256 index, uint24 extraData" + ], + [ + "setupDecimals", + "(uint8 decimals_" + ], + [ + "Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n ", + "_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n uint256 currentAllowance = _allowances[_msgSender()][spender];\\n require(" + ], + [ + "prettier-ignore\\n for {", + " let temp := " + ], + [ + "Revert with a standard message if `account` is missing `role`.\\n *\\n * The ", + "format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\\n */\\n function _checkRole(bytes32 role, address account" + ], + [ + "on the return value: the return value is optional (but if data is returned, it must not be false).", + "\\n * @param token The token targeted by the call" + ], + [ + "ApprovalForAll} event.\\n */\\n function _setApprovalForAll", + "(\\n address owner,\\n address operator,\\n bool approved" + ], + [ + ");\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControl", + ").interfaceId || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account" + ], + [ + "verifyCallResultFromTarget(\\n address target,\\n bool success", + ",\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only " + ], + [ + "Equivalent to `_burn(tokenId, false)`.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n _burn(tokenId, false);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId, bool approvalCheck) internal virtual {\\n uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);\\n\\n address from = address(uint160(prevOwnershipPacked", + "));\\n\\n " + ], + [ + "Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The ", + "format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _check" + ], + [ + "if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract", + "\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {" + ], + [ + "decimals() external pure returns (", + "uint8" + ], + [ + ".\\n * For ", + "full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309" + ], + [ + ", \\\"ERC721: approve to caller", + "\\\");\\n _operatorApprovals[owner][operator] = approved;\\n emit ApprovalForAll(owner, operator, approved);\\n }\\n\\n /**\\n * @dev " + ], + [ + "character is ", + "48" + ], + [ + "owner != operator", + ", \\\"ERC721: approve to caller\\\");\\n _operatorApprovals[owner][operator] = approved;\\n emit ApprovalForAll(owner, operator, approved);\\n }\\n\\n /**\\n * @dev " + ], + [ + "IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Enumerable is IERC721 {\\n /**\\n * @dev Returns the ", + "total amount of tokens stored by the contract.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns a token ID owned by `owner` at a given `index` of its token list.\\n * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.\\n */\\n function tokenOfOwnerByIndex(address owner, uint256 index" + ], + [ + " bits\\r\\n *\\r\\n * _Available since v4.", + "7._\\r\\n */\\r\\n function " + ], + [ + "Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it.\\n */\\nabstract contract AccessControl", + " is Context, IAccessControl, ERC165 {\\n struct RoleData {\\n " + ], + [ + "implementing it ourselves. We ", + "use {" + ], + [ + ");\\n if (to.code.length != 0)\\n if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {\\n ", + "revert TransferToNonERC721ReceiverImplementer();\\n " + ], + [ + "uint256) {\\n // Counter underflow is impossible as _burnCounter cannot be incremented\\n // more than `_currentIndex - _startTokenId()` times.\\n unchecked {\\n ", + "return _currentIndex - _burnCounter - _startTokenId();\\n }\\n }\\n\\n /**\\n * @dev Returns the total amount of tokens minted in the contract.\\n */\\n function _totalMinted(" + ], + [ + "if (!hasRole(role, account)) {\\n revert(\\n string(\\n abi.encodePacked(\\n \\\"AccessControl: account ", + "\\\",\\n Strings.toHexString" + ], + [ + "\\n\\n // Updates:\\n // - `address` to the next owner.\\n // - `startTimestamp` to the timestamp of transfering.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `", + "true`.\\n _packedOwnerships[tokenId" + ], + [ + ".\\n unchecked {\\n // We can directly increment and decrement the balances.\\n ", + "--_packedAddressData[from]; // Updates: `balance -= 1`.\\n ++_packedAddressData[to]; // Updates: `balance += 1`." + ], + [ + "BITPOS_NUMBER_BURNED) - 1;\\n\\n // Updates:\\n // - `address` to the last owner.\\n // - `startTimestamp` to the timestamp of burning.\\n // - `burned` to `true`.\\n // - `nextInitialized` to `", + "true`.\\n _packedOwnerships[tokenId" + ], + [ + "\"0", + "123456789abcdef\"" + ], + [ + "This account ", + "cannot send tokens " + ], + [ + " != 0;\\n ", + "ownership.extraData = uint24(" + ], + [ + "`index`.\\n */\\n function _", + "setExtraDataAt(uint256 index, uint24 extraData" + ], + [ + "BITPOS_EXTRA_DATA = 232", + ";\\n\\n // Mask of all 256 bits in a packed ownership except the 24 bits for `extraData" + ], + [ + "value == 0) || (", + "token.allowance(address(this), spender) == 0" + ], + [ + "BITMASK_NEXT_INITIALIZED |", + " _nextExtraData(from, to, prevOwnershipPacked" + ], + [ + "startTokenId + quantity - 1", + ", address(0), to" + ], + [ + "Mask `msgSender", + "` to the lower 160 bits, in case the upper bits somehow aren't clean.\\n msgSender := and(msgSender" + ], + [ + "_EXTRA_DATA_COMPLEMENT = (1 << 232", + ") - 1;\\n\\n // The mask of the lower 160 bits for addresses" + ], + [ + "MAX_MINT_ERC2309_QUANTITY_LIMIT = 5000", + ";\\n\\n // The " + ], + [ + "extra data for the packed ownership ", + "data.\\n * The " + ], + [ + "msgSender == approvedAddress", + "`.\\n result := or(" + ], + [ + "bytes memory returndata = address(token).functionCall", + "(data, \\\"SafeERC20: " + ], + [ + "Directly sets the extra data for the ownership data ", + "`index`.\\n */\\n function _setExtraDataAt(uint256 index, uint24 extraData" + ], + [ + "Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * ", + "on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call" + ], + [ + "Packs ownership data into a single uint256", + ".\\n */\\n function _packOwnershipData(address owner, uint256 flags" + ], + [ + "` cannot be set on an unintialized ownership slot", + ".\\n */\\n error OwnershipNotInitializedForExtraData" + ], + [ + "returned result is shifted into position", + ".\\n */\\n function _nextExtraData" + ], + [ + "BITMASK_ADDRESS = (1 << 160", + ") - 1;\\n\\n // The maximum `quantity` that can be minted " + ], + [ + "BITPOS_START_TIMESTAMP) | flags", + "`.\\n result := " + ], + [ + "BITPOS_NEXT_INITIALIZED, eq(quantity, 1", + "))\\n " + ], + [ + "approvedAddress := sload(approvedAddressSlot", + ")\\n " + ], + [ + "`balance` and `numberMinted` have a maximum limit of 2**64.", + "\\n // `tokenId` has a maximum limit of 2**256" + ], + [ + "storage slot and value for the approved address ", + "of `tokenId`.\\n */\\n function _" + ], + [ + "It emits only one {ConsecutiveTransfer} as defined ", + "in\\n * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309" + ], + [ + "minted with ERC2309 exceeds the safety limit", + ".\\n */\\n error MintERC2309QuantityExceedsLimit();\\n\\n /**\\n * The `extraData" + ], + [ + "`nextInitialized` flag set if `quantity` equals 1", + ".\\n */\\n function _nextInitializedFlag(uint256 quantity" + ], + [ + "', v", + "rAmount, vestingRound" + ], + [ + "\\n * non-compliant with the ERC721 standard", + ".\\n * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309" + ], + [ + "or(owner, ", + "or(" + ], + [ + "\\n bytes4 retval", + "\\n ) {\\n return retval == " + ], + [ + "chiru", + "-" + ], + [ + "msgSender\\n ) private pure returns (", + "bool result" + ], + [ + "\\\");\\n (bool success, bytes memory returndata) = target.call{value: value}", + "(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.staticcall" + ], + [ + "functionCall} to ", + "perform this call" + ], + [ + ");\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account", + ") external;\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account" + ], + [ + ".\\n * Intended to be overridden by the cosumer contract", + ".\\n *\\n * `previousExtraData` - the value of `extraData` before transfer" + ], + [ + "in the low-level ", + "call" + ], + [ + "(\\n address from,\\n address to,\\n uint256 prevOwnershipPacked", + "\\n ) private view returns (uint256) {\\n uint24 extraData = uint24(prevOwnershipPacked " + ], + [ + "s for success ", + "in the low-level call" + ], + [ + ", which verifies ", + "that" + ], + [ + "Standardiz", + "ed" + ], + [ + "extraDataCasted;\\n // Cast ", + "`extraData` with assembly to avoid redundant masking.\\n assembly {\\n " + ], + [ + ") external;\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account", + ") external;\\n}\\n\"" + ], + [ + "check isContract ", + "if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {" + ], + [ + "(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCallWithValue(target, data", + ", 0, \\\"Address: low-level " + ], + [ + "\\n * {ConsecutiveTransfer} event is only permissible during contract creation", + ".\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `quantity` must be greater than 0.\\n *\\n * Emits a {ConsecutiveTransfer} event.\\n */\\n function _mint" + ], + [ + ") external view returns (bool);\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {", + "AccessControl-_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) external view returns (bytes32" + ], + [ + ".\\n *\\n * _Available since v4.8._\\n */\\n function ", + "verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only " + ], + [ + "bitmap._", + "data[bucket" + ], + [ + ") return (false, 0);\\r\\n ", + "return (true, " + ], + [ + "for more details", + ".\\n */\\n event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to" + ], + [ + "s).\\n *\\n * Calling this function outside of contract creation WILL make your contract", + "\\n * non-compliant with the ERC721 standard.\\n * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309" + ], + [ + "ConsecutiveTransfer(startTokenId, ", + "startTokenId + quantity - 1, address(0), to" + ], + [ + "),\\n * instead of a sequence of {Transfer} event(", + "s).\\n *\\n * Calling this function outside of contract creation WILL make your contract\\n * non-compliant with the ERC721 standard.\\n * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309" + ], + [ + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, \\\"ERC20: decreased allowance below zero\\\"));\\n return true;\\n }\\n\\n /**\\n * @dev ", + "Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n _balances[sender] = _balances[sender].sub(amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[recipient] = _balances[recipient].add(amount);\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` " + ], + [ + "(to, quantity);\\n\\n unchecked {\\n if (", + "to.code.length != 0) {\\n " + ], + [ + "BITMASK_NEXT_INITIALIZED) | _nextExtraData", + "(from, address(0), prevOwnershipPacked" + ], + [ + "using the provided one) in case of unsuccessful call or if target was not a contract", + ".\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only " + ], + [ + "s `quantity` tokens and transfers them to `to`.\\n *\\n * This function is intended for efficient minting only ", + "during contract creation.\\n *\\n * " + ], + [ + "\"TOKEN: Balance exceeds wallet size", + "!\"" + ], + [ + "low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {", + "\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata" + ], + [ + "index < end);\\n // Reentrancy protection", + ".\\n if (" + ], + [ + "target address contains contract ", + "code and also assert" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\\n * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\\n * by default, it can be ", + "overridden in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return " + ], + [ + ", address[] calldata path, address to, uint deadline)\\n external\\n returns (", + "uint[] memory amounts);\\n function " + ], + [ + "(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or ", + "using the provided one) in case of unsuccessful call or if target was not a contract.\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only " + ], + [ + "32;\\n result += 32;\\n }\\n if (value >= 10**16) {\\n value /= 10**", + "16;\\n result += 16;\\n }\\n if (value >= 10**8) {\\n value /= 10**" + ], + [ + "64;\\n result += 64;\\n }\\n if (value >= 10**32) {\\n value /= 10**", + "32;\\n result += 32;\\n }\\n if (value >= 10**16) {\\n value /= 10**16;\\n result += 16;\\n }\\n if (value >= 10**8) {\\n value /= 10**" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Called during each token transfer to set the 24bit `extraData` field", + ".\\n * Intended to be overridden by the cosumer contract.\\n *\\n * `previousExtraData` - the value of `extraData` before transfer" + ], + [ + ",\\n bytes32 root,\\n bytes32[] memory leaves", + "\\n ) internal pure returns (bool) {\\n return " + ], + [ + "ASCII index of the '0' ", + "character is 48" + ], + [ + "2;\\n result += 2;\\n }\\n if (value >= 10**", + "1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base " + ], + [ + "Casted;\\n // Cast `aux", + "` with assembly to avoid redundant masking.\\n assembly {\\n auxCasted := aux" + ], + [ + "\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a ", + "low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata" + ], + [ + ",\\n bytes memory _data\\n ) internal virtual {\\n _mint(to, tokenId);\\n require(\\n _checkOnERC721Received", + "(address(0), to, tokenId, _data" + ], + [ + ".\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, `tokenId` will be burned by `from`.\\n * - `from` and `to` are never both zero.\\n */\\n function _extraData(\\n address from,\\n address to,\\n uint24 previousExtraData", + "\\n ) internal view virtual returns (uint24) {}\\n\\n /**\\n * @dev " + ], + [ + ", string memory errorMessage) private pure {\\n // Look for revert reason and bubble it up if present\\n if (", + "returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n " + ], + [ + "IERC721Receiver-onERC721Received}, which is called for each safe transfer.\\n * - `quantity` must be greater than 0.\\n *\\n * See {_mint}", + ".\\n *\\n * Emits a {Transfer} event for each mint.\\n */\\n function _safeMint(\\n address to,\\n uint256 quantity" + ], + [ + "cannot exceed 2**256 - 1 (max value of uint256).\\n */\\ncontract ERC721A is IERC721A", + " {\\n // " + ], + [ + ";\\n uint256 index = end - quantity", + ";\\n do {\\n " + ], + [ + "\\n // This limit is to prevent overflows on the address data entries.", + "\\n // For a limit of 5000, a total of 3.689e15 calls to " + ], + [ + "4;\\n result += 4;\\n }\\n if (value >= 10**2) {\\n value /= 10**", + "2;\\n result += 2;\\n }\\n if (value >= 10**1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base " + ], + [ + "8;\\n result += 8;\\n }\\n if (value >= 10**4) {\\n value /= 10**", + "4;\\n result += 4;\\n }\\n if (value >= 10**2) {\\n value /= 10**2;\\n result += 2;\\n }\\n if (value >= 10**1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base " + ], + [ + ") internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> 2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= 10**64) {\\n value /= 10**", + "64;\\n result += 64;\\n }\\n if (value >= 10**32) {\\n value /= 10**32;\\n result += 32;\\n }\\n if (value >= 10**16) {\\n value /= 10**16;\\n result += 16;\\n }\\n if (value >= 10**8) {\\n value /= 10**" + ], + [ + "`newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {AccessControl-_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account", + ") external view returns (bool);\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {AccessControl-_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) external view returns (bytes32" + ], + [ + "Role(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n bytes32 previousAdminRole = getRoleAdmin(role", + ");\\n _roles[role].adminRole = adminRole;\\n emit RoleAdminChanged(role, previousAdminRole, adminRole" + ], + [ + "(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\\n _transfer(sender, recipient, amount);\\n _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, \\\"ERC20: transfer amount exceeds allowance\\\"));\\n return true;\\n }\\n\\n /**\\n * @dev Atomically increases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)", + ");\\n return true;\\n }\\n\\n /**\\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n *\\n * This is an alternative to {approve} that can be used as a mitigation for\\n * problems described in {IERC20-approve}.\\n *\\n * Emits an {Approval} event indicating the updated allowance.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `spender` must have allowance for the caller of at least\\n * `subtractedValue`.\\n */\\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, \\\"ERC20: decreased allowance below zero\\\"));\\n return true;\\n }\\n\\n /**\\n * @dev Moves tokens `amount` from `sender` to `recipient`.\\n *\\n * This is internal function is equivalent to {transfer}, and can be used to\\n * e.g. implement automatic token fees, slashing mechanisms, etc.\\n *\\n * Emits a {Transfer} event.\\n *\\n * Requirements:\\n *\\n * - `sender` cannot be the zero address.\\n * - `recipient` cannot be the zero address.\\n * - `sender` must have a balance of at least `amount`.\\n */\\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\\n require(sender != address(0), \\\"ERC20: transfer from the zero address\\\");\\n require(recipient != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(sender, recipient, amount);\\n\\n _balances[sender] = _balances[sender].sub(amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n _balances[recipient] = _balances[recipient].add(amount);\\n emit Transfer(sender, recipient, amount);\\n }\\n\\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n * the total supply.\\n *\\n * Emits a {Transfer} event with `from` " + ], + [ + "ERC721Receiver interface.\\n */\\n error TransferToNonERC721ReceiverImplementer();\\n\\n /**\\n * Cannot transfer to the zero address.\\n */\\n error TransferToZeroAddress();\\n\\n /**\\n * The token does not exist.\\n */\\n error URIQueryForNonexistentToken();\\n\\n /**\\n * The `quantity` ", + "minted with ERC2309 exceeds the safety limit.\\n */\\n error MintERC2309QuantityExceedsLimit();\\n\\n /**\\n * The `extraData" + ], + [ + "utils/Context.sol\\\";\\nimport \\\"../utils/Strings.sol\\\";\\nimport \\\"../", + "utils/introspection/ERC165.sol\\\";\\n\\n/**\\n * @dev " + ], + [ + ".\\n unchecked {\\n // We can directly increment and decrement the balances.\\n --_packedAddressData[from]; // Updates: `balance -= 1`.\\n ++_packedAddressData[to]; // Updates: `balance += 1`.", + "\\n\\n // Updates:\\n // - `address` to the next owner.\\n // - `startTimestamp` to the timestamp of transfering.\\n // - `burned` to `false`.\\n // - `nextInitialized` to `true`.\\n _packedOwnerships[tokenId" + ], + [ + "This account cannot send tokens ", + "until trading is " + ], + [ + "extra data for the packed ownership data.\\n * The ", + "returned result is shifted into position.\\n */\\n function _nextExtraData" + ], + [ + "bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: ", + "low-level call failed" + ], + [ + "Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call", + ".\\n * @param data The " + ], + [ + "` cannot be set on an unintialized ownership slot.\\n */\\n error OwnershipNotInitializedForExtraData", + "();\\n\\n " + ], + [ + "It emits only one {ConsecutiveTransfer} as defined in\\n * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309", + "),\\n * instead of a sequence of {Transfer} event(s).\\n *\\n * Calling this function outside of contract creation WILL make your contract\\n * non-compliant with the ERC721 standard.\\n * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309" + ], + [ + "', vrAmount, vestingRound", + "1" + ], + [ + "functionCall} to perform this call", + ", which verifies that" + ], + [ + ");\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account", + ") external;\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\"" + ], + [ + "extraDataCasted;\\n // Cast `extraData` with assembly to avoid redundant masking.\\n assembly {\\n ", + "extraDataCasted := extraData" + ], + [ + "check isContract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {", + "\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata" + ], + [ + "\\n * {ConsecutiveTransfer} event is only permissible during contract creation.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `quantity` must be greater than 0.\\n *\\n * Emits a {ConsecutiveTransfer} event.\\n */\\n function _mint", + "ERC2309" + ], + [ + "s `quantity` tokens and transfers them to `to`.\\n *\\n * This function is intended for efficient minting only during contract creation.\\n *\\n * ", + "It emits only one {ConsecutiveTransfer} as defined in\\n * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309),\\n * instead of a sequence of {Transfer} event(s).\\n *\\n * Calling this function outside of contract creation WILL make your contract\\n * non-compliant with the ERC721 standard.\\n * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309" + ], + [ + "target address contains contract code and also assert", + "s for success in the low-level call" + ], + [ + "(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only ", + "check isContract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Called during each token transfer to set the 24bit `extraData` field.\\n * Intended to be overridden by the cosumer contract.\\n *\\n * `previousExtraData` - the value of `extraData` before transfer", + ".\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be\\n * transferred to `to`.\\n * - When `from` is zero, `tokenId` will be minted for `to`.\\n * - When `to` is zero, `tokenId` will be burned by `from`.\\n * - `from` and `to` are never both zero.\\n */\\n function _extraData(\\n address from,\\n address to,\\n uint24 previousExtraData\\n ) internal view virtual returns (uint24) {}\\n\\n /**\\n * @dev " + ], + [ + ", string memory errorMessage) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n ", + "revert(errorMessage" + ], + [ + "8;\\n result += 8;\\n }\\n if (value >= 10**4) {\\n value /= 10**4;\\n result += 4;\\n }\\n if (value >= 10**2) {\\n value /= 10**2;\\n result += 2;\\n }\\n if (value >= 10**1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base ", + "10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log256(value);\\n return result + (rounding == Rounding.Up && 1 << (" + ], + [ + ") internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> 2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= 10**64) {\\n value /= 10**64;\\n result += 64;\\n }\\n if (value >= 10**32) {\\n value /= 10**32;\\n result += 32;\\n }\\n if (value >= 10**16) {\\n value /= 10**16;\\n result += 16;\\n }\\n if (value >= 10**8) {\\n value /= 10**", + "8;\\n result += 8;\\n }\\n if (value >= 10**4) {\\n value /= 10**4;\\n result += 4;\\n }\\n if (value >= 10**2) {\\n value /= 10**2;\\n result += 2;\\n }\\n if (value >= 10**1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log256(value);\\n return result + (rounding == Rounding.Up && 1 << (" + ], + [ + "`newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {AccessControl-_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {AccessControl-_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) external view returns (bytes32", + ");\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\"" + ], + [ + "ERC721Receiver interface.\\n */\\n error TransferToNonERC721ReceiverImplementer();\\n\\n /**\\n * Cannot transfer to the zero address.\\n */\\n error TransferToZeroAddress();\\n\\n /**\\n * The token does not exist.\\n */\\n error URIQueryForNonexistentToken();\\n\\n /**\\n * The `quantity` minted with ERC2309 exceeds the safety limit.\\n */\\n error MintERC2309QuantityExceedsLimit();\\n\\n /**\\n * The `extraData", + "` cannot be set on an unintialized ownership slot.\\n */\\n error OwnershipNotInitializedForExtraData();\\n\\n " + ], + [ + "extra data for the packed ownership data.\\n * The returned result is shifted into position.\\n */\\n function _nextExtraData", + "(\\n address from,\\n address to,\\n uint256 prevOwnershipPacked\\n ) private view returns (uint256) {\\n uint24 extraData = uint24(prevOwnershipPacked " + ], + [ + "s `quantity` tokens and transfers them to `to`.\\n *\\n * This function is intended for efficient minting only during contract creation.\\n *\\n * It emits only one {ConsecutiveTransfer} as defined in\\n * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309),\\n * instead of a sequence of {Transfer} event(s).\\n *\\n * Calling this function outside of contract creation WILL make your contract\\n * non-compliant with the ERC721 standard.\\n * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309", + "\\n * {ConsecutiveTransfer} event is only permissible during contract creation.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `quantity` must be greater than 0.\\n *\\n * Emits a {ConsecutiveTransfer} event.\\n */\\n function _mintERC2309" + ], + [ + "(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only check isContract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata", + ", string memory errorMessage) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage" + ], + [ + " ", + "implementation " + ], + [ + " ", + "should be " + ], + [ + "!", + "swapping" + ], + [ + ".", + "\\n\\n" + ], + [ + "/", + "sign" + ], + [ + "@", + "4." + ], + [ + "A", + "pe" + ], + [ + "B", + "ad" + ], + [ + "B", + "enefici" + ], + [ + "D", + "App" + ], + [ + "H", + "igh" + ], + [ + "M", + "ail" + ], + [ + "T", + "ayl" + ], + [ + "U", + "UP" + ], + [ + "X", + "OR" + ], + [ + "[", + "hashed " + ], + [ + "_", + "ERC721" + ], + [ + "_", + "version" + ], + [ + "_", + "cooldown" + ], + [ + "`", + "values" + ], + [ + "b", + "af" + ], + [ + "b", + "id " + ], + [ + "c", + "6" + ], + [ + "d", + "8" + ], + [ + "e", + ", and the " + ], + [ + "g", + "e " + ], + [ + "h", + "ind " + ], + [ + "i", + "de " + ], + [ + "l", + "en " + ], + [ + "p", + "xCVX" + ], + [ + "r", + "ing" + ], + [ + "s", + "it" + ], + [ + "s", + ")\\\")," + ], + [ + "x", + " <= " + ], + [ + "y", + "_" + ], + [ + "{", + "\\r\\n" + ], + [ + "}", + "\\n }\\n" + ], + [ + "en", + "ci" + ], + [ + "\\n ", + "(bool success, ) = recipient.call{ value: amount " + ], + [ + "in", + "\\n // the " + ], + [ + ", ", + "string calldata " + ], + [ + "ac", + "y" + ], + [ + "\\n * ", + "applications that interact with token contracts will not expect" + ], + [ + "address", + "'s " + ], + [ + "ing", + "\\n * https://" + ], + [ + "token", + "Out " + ], + [ + "end", + ";\\n }\\n _afterTokenTransfers(address(0), to, startTokenId, quantity);\\n }\\n\\n /**\\n * @dev Mint" + ], + [ + "is", + "OperatorFilte" + ], + [ + "ic", + ", and " + ], + [ + "a ", + "xref:" + ], + [ + "To", + "Subscribe" + ], + [ + "owner", + ", \\\"" + ], + [ + "as", + "ible" + ], + [ + "cont", + "ext " + ], + [ + "dev", + "Address" + ], + [ + "im", + "m" + ], + [ + "Token", + "Owner" + ], + [ + " ", + "//\\n// " + ], + [ + "Owner", + "To" + ], + [ + "call", + "ing the " + ], + [ + "an ", + "owner " + ], + [ + "- ", + "The maximum " + ], + [ + "Transfer", + "(address,address,uint256)\\\"))" + ], + [ + "========", + "=" + ], + [ + " = ", + "40" + ], + [ + " = ", + "set._indexes[value" + ], + [ + "sh", + "uff" + ], + [ + "in ", + "`" + ], + [ + ") internal ", + "override {\\n " + ], + [ + ". ", + "Protocol" + ], + [ + ". ", + "In " + ], + [ + "In", + "Wei" + ], + [ + "} ", + "instead" + ], + [ + "set", + ".\\n " + ], + [ + "set", + "s]" + ], + [ + "total", + "BuyFees" + ], + [ + " to ", + "delete with the last " + ], + [ + "Address", + "Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(" + ], + [ + "..", + ". " + ], + [ + "Supp", + "ort" + ], + [ + " of ", + "primitive" + ], + [ + "by ", + "`" + ], + [ + "require(", + "msg.sender == " + ], + [ + "as ", + "efficient" + ], + [ + "value ", + "to the index where the " + ], + [ + "par", + "ty " + ], + [ + "be", + "hind " + ], + [ + "For", + "ced" + ], + [ + "contract ", + "upgrade" + ], + [ + "Of", + "Filtered" + ], + [ + "a s", + "ale " + ], + [ + "(uint256 ", + "_mintAmount" + ], + [ + "token ", + "type `id" + ], + [ + "s.", + "\\n function " + ], + [ + "The ", + "implementation of the " + ], + [ + ";\\n\\n", + "abstract contract " + ], + [ + "operator", + " is not " + ], + [ + "name", + "`: " + ], + [ + ";\\n\\n ", + "/* " + ], + [ + "import ", + "{\\n " + ], + [ + ").", + "\\r\\n *\\r\\n * " + ], + [ + " (", + "{_" + ], + [ + "bytes32 ", + "last" + ], + [ + "will ", + "make the " + ], + [ + "With", + "Code" + ], + [ + "balanceOf", + "[from" + ], + [ + "_A", + "R" + ], + [ + "il", + "er will " + ], + [ + "content", + "s)\\\")," + ], + [ + "\\n // ", + "will " + ], + [ + " of the ", + "encod" + ], + [ + "] = ", + "set._values.length" + ], + [ + "safe", + "Approve " + ], + [ + "Index", + " - 1;\\n uint256 lastIndex = " + ], + [ + "`.", + "\\n *\\n * This " + ], + [ + "`amount", + "s` " + ], + [ + ";\\n ", + "address " + ], + [ + ".\\n */\\n function _", + "setupDecimals(uint8 decimals_" + ], + [ + "buy", + "feeRate." + ], + [ + "hash", + " of " + ], + [ + "hash", + "struct" + ], + [ + ";\\n ", + "return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev " + ], + [ + "0.8.0", + " <0.9.0" + ], + [ + "transferFrom", + "(address sender, address recipient, uint256 amount" + ], + [ + "))", + ")" + ], + [ + "ID", + "eleg" + ], + [ + "Set", + "_(" + ], + [ + "Set", + ";\\n * }\\n * ```\\n *\\n * As of " + ], + [ + "Set", + ".\\n // This means that we can only create new " + ], + [ + "set ", + "values\\n " + ], + [ + "abi.encode", + "` and `" + ], + [ + "AS", + "E" + ], + [ + " for ", + "the current " + ], + [ + "balance ", + "-= 1;\\n " + ], + [ + "main", + "Router" + ], + [ + "Ownable", + ".sol\"" + ], + [ + "sc", + "ra" + ], + [ + "is not ", + "fe" + ], + [ + "interface ", + "is " + ], + [ + "Pool", + "Manager" + ], + [ + ")\\n ", + "uint256 " + ], + [ + "ain", + "`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall" + ], + [ + "will be ", + "zero" + ], + [ + "Paus", + "e " + ], + [ + "add(", + "Set storage set, bytes32 value) private returns (bool) {\\n " + ], + [ + "\"@openzeppelin/contracts/", + "token/ERC20/extensions/ERC20Burnable.sol\"" + ], + [ + "_value", + "s array " + ], + [ + "::", + "upgrad" + ], + [ + "Enabled", + "Trading" + ], + [ + "_t", + "x" + ], + [ + "has ", + "issues " + ], + [ + "man", + "ually " + ], + [ + " - ", + "start" + ], + [ + "uint256) {\\n return ", + "set._values.length" + ], + [ + " and ", + "parameter " + ], + [ + "Admin", + "(" + ], + [ + "Admin", + "Changed" + ], + [ + "signed ", + "via " + ], + [ + "ed in ", + "their " + ], + [ + "ne", + "ed in their " + ], + [ + "tra", + "its" + ], + [ + "(uint256 tokenId", + ")\\n private\\n view\\n returns (uint256 " + ], + [ + "one ", + "in\\n // the " + ], + [ + "Timestamp", + " = " + ], + [ + ".\\n *\\n * ", + "Sets " + ], + [ + "OO", + "_" + ], + [ + "del", + "Bots" + ], + [ + "Set ", + "type with\\n // bytes32 " + ], + [ + "Set ", + "implementation uses private functions, and user-facing\\n // implementations (such as " + ], + [ + "gener", + "ic, and " + ], + [ + "that is ", + "then " + ], + [ + "s for ", + "this " + ], + [ + "version", + "`: " + ], + [ + "true ", + "if the " + ], + [ + "() ", + "== " + ], + [ + "\\n // ", + "solhint-disable-next-line no-inline-assembly" + ], + [ + "recover", + "} to " + ], + [ + ") internal view virtual returns (", + "uint256) {\\n return " + ], + [ + "(value", + ");\\n // The " + ], + [ + "type", + "-specific " + ], + [ + "they ", + "need in their " + ], + [ + "the current ", + "major " + ], + [ + "Uint", + "Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(" + ], + [ + "already ", + "has " + ], + [ + "great", + "er " + ], + [ + "tokenId ", + "= " + ], + [ + "struct", + "], " + ], + [ + "Lock", + "s" + ], + [ + "(bytes32 ", + "structHash" + ], + [ + "tokenA", + ",\\r\\n address " + ], + [ + "signer", + " of a " + ], + [ + "{IERC20-", + "approve}." + ], + [ + "_data", + "_type" + ], + [ + "can be used ", + "together with {" + ], + [ + "abstract", + "_data_type" + ], + [ + ") external view returns (uint256", + ");\\n\\n function " + ], + [ + "Allowed", + "SeaDrop" + ], + [ + "contain", + "ing " + ], + [ + "Set storage set", + ", uint256 index) private view returns (" + ], + [ + "Transfers ", + "`tokenId` from `from` to `to" + ], + [ + "royalty", + "-" + ], + [ + "/\\n ", + "function " + ], + [ + "Acc", + "ess " + ], + [ + "contracts ", + "using a " + ], + [ + "Can ", + "only " + ], + [ + "`) ", + "are supported" + ], + [ + "values ", + "on the set. O(1" + ], + [ + "\\n * {", + "decimals} to ever change, and may work incorrectly if it does" + ], + [ + "Fee ", + "/ " + ], + [ + "value is ", + "stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n " + ], + [ + "hash ", + "can be used together with {" + ], + [ + "rewards", + "Cycle" + ], + [ + "ing to ", + "obtain the " + ], + [ + "ing.", + "\\n // The " + ], + [ + "Start", + "ed(" + ], + [ + "manag", + "er " + ], + [ + ",\\r\\n ", + "uint256 " + ], + [ + ", as ", + "implemented by the " + ], + [ + "Is", + "Active" + ], + [ + "implementation ", + "in Solidity " + ], + [ + "-contracts.adoc", + "[" + ], + [ + "vot", + "es for " + ], + [ + "{IERC20-approve}", + ", and its " + ], + [ + "around ", + "the\\n // " + ], + [ + "html", + "[`eth_sign" + ], + [ + ".\\n * ", + "@dev " + ], + [ + ".\\n * ", + "To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract" + ], + [ + "(), ", + "structHash" + ], + [ + "Initializes the ", + "domain separator" + ], + [ + "name of the ", + "signing domain" + ], + [ + "name of the ", + "DApp" + ], + [ + "index ", + "0\\n // " + ], + [ + ")) {\\n ", + "revert " + ], + [ + ")) {\\n ", + "set._values" + ], + [ + "keccak256(\\\"", + "Mail" + ], + [ + "uint256, ", + "uint256, " + ], + [ + "ing of ", + "typed structured " + ], + [ + "guide", + "/sign" + ], + [ + "element", + " (" + ], + [ + "element", + " to delete with the last " + ], + [ + "mean", + "s a value " + ], + [ + "name = ", + "\\\"" + ], + [ + ") private view returns (", + "uint256 result" + ], + [ + "ing-", + "smart" + ], + [ + "ing-", + "data." + ], + [ + "EnumerableSet", + "s for types that fit\\n // in bytes32.\\n\\n struct " + ], + [ + "successful", + ".\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract" + ], + [ + ", uint256 index", + ") internal view returns (uint256) {\\n return " + ], + [ + "super._", + "mint" + ], + [ + "User", + "Balance" + ], + [ + "such a ", + "generic " + ], + [ + "\"@", + "1inch/" + ], + [ + "SafeERC20", + "\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token" + ], + [ + "specified ", + "in the EIP" + ], + [ + "(\\r\\n address ", + "tokenA,\\r\\n address " + ], + [ + "Wrapp", + "ed " + ], + [ + "AddressSet", + "\\n\\n struct " + ], + [ + "AddressSet", + ") are just wrappers " + ], + [ + "emitted ", + "when " + ], + [ + "filtered", + "Operator" + ], + [ + "filtered", + "Operators" + ], + [ + "exceed ", + "max " + ], + [ + "_setup", + "Role(" + ], + [ + "possible", + ", use {" + ], + [ + "random", + "ness " + ], + [ + "value was ", + "stored\\n " + ], + [ + "test", + "/" + ], + [ + "at(", + "Set storage set, uint256 index) private view returns (" + ], + [ + "` (`", + "AddressSet" + ], + [ + "domain separator", + " ({_" + ], + [ + "domain separator", + " for the current " + ], + [ + "allow ", + "list" + ], + [ + "reduc", + "es " + ], + [ + "copy", + "Entries" + ], + [ + "copy", + "Existing" + ], + [ + "launch", + "Block" + ], + [ + "in the set. O(1", + ").\\n */\\n function _contains(" + ], + [ + "MerkleProof", + ".sol\"" + ], + [ + " = value", + "Index - 1;\\n uint256 lastIndex = " + ], + [ + "right", + "s" + ], + [ + "Comp", + "iler will " + ], + [ + "Bpt", + "In" + ], + [ + "be\\n * ", + "successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract" + ], + [ + "contracts", + "@4." + ], + [ + ") private pure returns (", + "uint256 result) {\\n // " + ], + [ + "Equivalent to ", + "contains(set, value" + ], + [ + ")\\n internal", + "\\n view\\n returns (" + ], + [ + "s on ", + "an event" + ], + [ + ". This function ", + "has issues " + ], + [ + "Hand", + "l" + ], + [ + "unicode", + "\\\"" + ], + [ + ". To ", + "increase and decrease " + ], + [ + "ECDSA-", + "recover} to " + ], + [ + "step", + " of the encod" + ], + [ + "}\\r\\n\\r\\n", + "\\tfunction " + ], + [ + "_sell", + "Fee" + ], + [ + "thus ", + "this contract does not " + ], + [ + "NOTE: This ", + "contract implements the " + ], + [ + "set._values", + ".length - 1" + ], + [ + "set._values", + ".pop(" + ], + [ + "Privat", + "e" + ], + [ + "TypedDataV4", + "` in " + ], + [ + "voting power ", + "history " + ], + [ + "underlying ", + "Set.\\n // This means that we can only create new " + ], + [ + "{\\n // ", + "To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic " + ], + [ + "Set storage set, bytes32 value", + ") private view returns (bool) {\\n return " + ], + [ + "tokenOfOwnerByIndex", + "}.\\n */\\n function " + ], + [ + "calculate", + "Invariant(" + ], + [ + "until", + " the " + ], + [ + "keccak256(bytes(", + "mail" + ], + [ + "{_", + "hashTypedDataV4" + ], + [ + "protect against ", + "replay attack" + ], + [ + "(address to", + ",string " + ], + [ + "AddressSet storage set", + ", uint256 index) internal view returns (address) {\\n return " + ], + [ + "UintSet storage set", + ", uint256 index) internal view returns (uint256) {\\n return " + ], + [ + "}) ", + "that is used " + ], + [ + "\\n\\n struct ", + "UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(" + ], + [ + "hash of the ", + "fully " + ], + [ + "number of tokens in ", + "`owner`'s " + ], + [ + "Boolean", + "Slot" + ], + [ + "itself", + ". Protocol" + ], + [ + "Loan", + "ed" + ], + [ + "domain separator ", + "was designed to be " + ], + [ + "UintSet", + "`) are supported" + ], + [ + "UintSet", + "\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(" + ], + [ + "for this ", + "domain" + ], + [ + "These ", + "parameters " + ], + [ + "returns the ", + "hash of the fully " + ], + [ + "hashTypedDataV4", + "(bytes32 structHash" + ], + [ + ";\\n\\n /**\\n * @dev Sets the values for {name} and {symbol", + "}, initializes {decimals} with\\n * a default value of 18.\\n *\\n * To select a different value for {decimals}, use {_setupDecimals}.\\n *\\n * All three of these values are immutable: they can only be set once during\\n * construction" + ], + [ + "domainSeparatorV4", + "(), structHash" + ], + [ + "domainSeparatorV4", + "}) that is used " + ], + [ + "tokenByIndex", + "}.\\n */\\n function " + ], + [ + "ERC721A__", + "IERC721Receiver(to).onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert TransferToNonERC721ReceiverImplementer();\\n } else {\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n " + ], + [ + "stash", + "Version" + ], + [ + "https://eips.ethereum.org/EIPS/eip-712", + "[EIP 712]" + ], + [ + ".length - 1", + " == totalHashes, \\\"MerkleProof: invalid multiproof\\\");\\n\\n // The xxxPos values are \\\"pointers\\\" to the next value to consume in each array. All accesses are done using\\n // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \\\"pop\\\".\\n bytes32[] memory hashes = new bytes32[](totalHashes);\\n uint256 leafPos = 0;\\n uint256 hashPos = 0;\\n uint256 proofPos = 0;\\n // At each step, we compute the next hash using two values:\\n // - a value from the \\\"main queue\\\". If not all leaves have been consumed, we get the next leaf, otherwise we\\n // get the next hash.\\n // - depending on the flag, either another " + ], + [ + "ual ", + "fork" + ], + [ + "unk", + "s" + ], + [ + "encoding ", + "known as " + ], + [ + "encoding ", + "specified in the EIP" + ], + [ + "encoding ", + "itself. Protocol" + ], + [ + "valueIndex", + " != 0" + ], + [ + "valueIndex", + " = set._indexes[value" + ], + [ + "final ", + "step of the encod" + ], + [ + "encoded ", + "EIP712 message " + ], + [ + "explicitOwnership", + "s" + ], + [ + "message", + ". For example" + ], + [ + " from the ", + "_values array " + ], + [ + "Meta", + "Mask" + ], + [ + "initialized ", + "ownership slot" + ], + [ + "set._indexes[value", + "] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of " + ], + [ + "set._indexes[value", + "];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev " + ], + [ + "set._indexes[value", + "] = set._values.length" + ], + [ + "] = _packOwnershipData(\\n ", + "from,\\n " + ], + [ + "Set {\\n ", + "// Storage of " + ], + [ + "Returns true if the value is ", + "in the set. O(1).\\n */\\n function _contains(" + ], + [ + "Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * ", + "present.\\n */\\n function _remove(" + ], + [ + ";\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already ", + "present.\\n */\\n function _" + ], + [ + "result * ", + "8" + ], + [ + "\"TOKEN: ", + "Max Transaction " + ], + [ + "\"TOKEN: ", + "This account cannot send tokens until trading is " + ], + [ + "GSN", + "/Context" + ], + [ + "`address", + "` (`AddressSet" + ], + [ + "Whenever ", + "possible, use {" + ], + [ + "should only be called ", + "when setting " + ], + [ + "Max wallet exceed", + "ed" + ], + [ + ".io/", + "guide/sign" + ], + [ + "function selector", + " of `" + ], + [ + "docs.", + "met" + ], + [ + "it, ", + "use" + ], + [ + "value to ", + "delete is" + ], + [ + "Content", + "s))" + ], + [ + "skim", + "(address to" + ], + [ + "safeIncreaseAllowance", + "} " + ], + [ + "safeDecreaseAllowance", + "} instead" + ], + [ + "Art", + "blocks" + ], + [ + "transfer from ", + "the zero address\\\");\\r\\n require(" + ], + [ + ",\\n * ", + "which allows you to call the safe operations as `token.safeTransfer(...)`, etc" + ], + [ + ")\\n if (!", + "isApprovedForAll(owner, _msgSenderERC721A())" + ], + [ + ") internal returns (bool) {\\n return _remove(", + "set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev " + ], + [ + ") internal view returns (bool) {\\n return _contains(", + "set._inner, bytes32(value" + ], + [ + "set._values[", + "lastIndex" + ], + [ + "set._values[", + "toDeleteIndex] = " + ], + [ + "AddressSet storage set, address value", + ") internal returns (bool) {\\n return _remove(" + ], + [ + "AddressSet storage set, address value", + ") internal view returns (bool) {\\n return _contains(" + ], + [ + "AddressSet storage set, address value", + ") internal returns (bool) {\\n return _add(" + ], + [ + "UintSet storage set, uint256 value", + ") internal returns (bool) {\\n return _add(" + ], + [ + "UintSet storage set, uint256 value", + ") internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev " + ], + [ + "UintSet storage set, uint256 value", + ") internal view returns (bool) {\\n return _contains(set._inner, bytes32(value" + ], + [ + "implement the ", + "type-specific " + ], + [ + "implement the ", + "encoding itself. Protocol" + ], + [ + "security/Pausable", + ".sol\"" + ], + [ + "combin", + "ation of `" + ], + [ + ");\\n\\n _afterTokenTransfer", + "(sender, recipient, amount" + ], + [ + "mail", + "To" + ], + [ + " is a ", + "standard for " + ], + [ + "Returns true if the value is in the set. O(1).\\n */\\n function contains(", + "AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(" + ], + [ + "Returns true if the value is in the set. O(1).\\n */\\n function contains(", + "UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value" + ], + [ + "Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(", + "AddressSet storage set, address value) internal returns (bool) {\\n return _remove(" + ], + [ + "Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(", + "UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev " + ], + [ + ".push", + "(value);\\n // The " + ], + [ + "(\\r\\n address from,\\r\\n address to,\\r\\n uint256 ", + "tokenId" + ], + [ + "split", + "ting the " + ], + [ + "value in the ", + "`values" + ], + [ + "(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes memory _data\\n ) private returns (bool) {\\n ", + "try ERC721A__IERC721Receiver(to).onERC721Received(_msgSenderERC721A(), from, tokenId, _data) returns (" + ], + [ + "if (!_", + "contains(set, value" + ], + [ + " because ", + "index 0\\n // " + ], + [ + ", \\\"SafeERC20: ", + "decreased allowance below zero" + ], + [ + "an element", + " from the _values array " + ], + [ + "ADMIN", + "_ROLE" + ], + [ + "== 0) revert ", + "OwnershipNotInitializedForExtraData" + ], + [ + "version of the ", + "signing domain" + ], + [ + "version of the ", + "encoding known as " + ], + [ + "usage ", + "is discourag" + ], + [ + ".\\n *\\n * WARNING: ", + "This function should only be called from the constructor. Most" + ], + [ + "];\\n\\n if (", + "valueIndex != 0" + ], + [ + "TRANSFER_", + "EVENT_SIGNATUR" + ], + [ + "string memory name, string memory ", + "version" + ], + [ + "into a single ", + "256bit " + ], + [ + "except through ", + "a xref:" + ], + [ + "string memory _name", + ",\\n string memory _symbol" + ], + [ + "obtain the ", + "signer of a " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(", + "AddressSet storage set" + ], + [ + "https://eips.ethereum.org/EIPS/eip-712#definition-of-", + "hashstruct" + ], + [ + "contract implements the ", + "EIP 712 " + ], + [ + "isCodeHash", + "Filtered" + ], + [ + "isCodeHash", + "OfFiltered" + ], + [ + "subscriber", + "s" + ], + [ + "filteredCodeHash", + "es" + ], + [ + "Set storage set, bytes32 value) private returns (bool) {\\n ", + "// We read and store the " + ], + [ + "Elements are ", + "added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - " + ], + [ + "set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev ", + "Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev " + ], + [ + "\\n@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@", + "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" + ], + [ + "else {", + "\\n " + ], + [ + ");\\n\\n // Clear approvals from the previous owner.\\n assembly {\\n if approvedAddress {\\n // This is equivalent to `delete _tokenApprovals[tokenId]`.\\n sstore(approvedAddressSlot, 0)\\n }\\n }\\n\\n // Underflow of the sender's balance is impossible because we check for\\n // ownership above and the recipient's balance can't realistically overflow.\\n // Counter overflow is incredibly unrealistic as `tokenId` would have to be 2**256", + ".\\n unchecked {\\n // Updates:\\n // - `balance -= 1`.\\n // - `numberBurned += 1`.\\n //\\n // We can directly decrement the balance, and increment the number burned.\\n // This is equivalent to `packed -= 1; packed += 1" + ], + [ + "WH", + "ITE" + ], + [ + "EnumerableSet for EnumerableSet.AddressSet", + ";\\n *\\n * // Declare a set state variable\\n * " + ], + [ + "token/ERC721/IERC721.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to", + "`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes calldata data\\n ) external;\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to" + ], + [ + "_exists(", + "nextTokenId" + ], + [ + "Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom", + "(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\"" + ], + [ + "Given ", + "an already " + ], + [ + "properly ", + "updating" + ], + [ + "chedul", + "ed" + ], + [ + "path[0] = address(this", + ");\\n " + ], + [ + "scratch ", + "spac" + ], + [ + "can use this function", + ".\\n *\\n * @param seaDropImpl" + ], + [ + "EnumerableSet.AddressSet ", + "private my" + ], + [ + "the user ", + "readable " + ], + [ + "Set storage set) private view returns (", + "uint256) {\\n return set._values.length" + ], + [ + "(owner(), ", + "true" + ], + [ + "Library for manag", + "ing\\n * https://" + ], + [ + "string memory) {\\n if (!_exists(tokenId)) revert URIQueryForNonexistentToken();\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length != ", + "0 ? string(abi.encodePacked(baseURI, _toString(tokenId))) : ''" + ], + [ + "emporarily", + "Pausable" + ], + [ + "WAL", + "LE" + ], + [ + "\\n * contract ", + "returns false). Tokens that return no value (and instead revert " + ], + [ + "`, as ", + "defined in " + ], + [ + ");\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(\\n address to,\\n uint256 tokenId", + ",\\n bytes memory _data\\n ) internal virtual {\\n _mint(to, tokenId);\\n require(\\n _checkOnERC721Received(address(0), to, tokenId, _data" + ], + [ + "IERC20[] memory ", + "tokens" + ], + [ + "Solmate (https://github.com/", + "transmissions11/solmate/blob/main/src/" + ], + [ + "en.wikipedia.org/wiki/", + "Set_(" + ], + [ + "decimals = decimals_", + ";\\n }\\n\\n /**\\n * @dev " + ], + [ + "\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function ", + "safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes memory _data\\n " + ], + [ + "Administr", + "ator" + ], + [ + "at any ", + "point" + ], + [ + "an initial ", + "allowance" + ], + [ + "schem", + "e, and the " + ], + [ + "is not in the ", + "set.\\n " + ], + [ + "emit OwnershipTransferred(_owner, newOwner", + ");\\n _owner = newOwner" + ], + [ + ")[", + "sets]" + ], + [ + "while still ", + "properly updating" + ], + [ + "Optimized ", + "for " + ], + [ + "Deprecated", + ". This function has issues " + ], + [ + "bytes32 internal constant _", + "IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc" + ], + [ + "JO", + "IN" + ], + [ + "ones ", + "found " + ], + [ + "bytes32[] ", + "_values" + ], + [ + "for {\\n ", + "let " + ], + [ + "(sender, recipient, amount);\\n\\n uint256 currentAllowance = _allowances[sender][_msgSender()];\\n require(", + "currentAllowance >= amount, \\\"ERC20: transfer amount exceeds allowance" + ], + [ + "_msgSenderERC721A() != owner", + ")\\n if (!isApprovedForAll(owner, _msgSenderERC721A())" + ], + [ + "s need to ", + "implement the type-specific " + ], + [ + "message digest ", + "that is then " + ], + [ + "\\n // If the ", + "address is zero, packed " + ], + [ + ";\\n\\n/*\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with GSN ", + "meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address payable) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes memory" + ], + [ + "similar to the ", + "ones found " + ], + [ + "ustodi", + "an" + ], + [ + "or when ", + "resetting " + ], + [ + "values.\\n // The ", + "Set implementation uses private functions, and user-facing\\n // implementations (such as " + ], + [ + "address[] memory path = new address[](2);\\n ", + "path[0] = address(this);\\n " + ], + [ + ")\\n // To delete ", + "an element from the _values array " + ], + [ + "Position of the ", + "value in the `values" + ], + [ + ").\\n */\\n function _length(", + "Set storage set) private view returns (uint256) {\\n return set._values.length" + ], + [ + "Move the last ", + "value to the index where the " + ], + [ + "uint256) _indexes", + ";\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _" + ], + [ + "have the following properties:\\n *\\n * - ", + "Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - " + ], + [ + "in O(1), we swap the ", + "element to delete with the last " + ], + [ + "array, and then remove the last ", + "element (" + ], + [ + "Update the index for the moved ", + "value" + ], + [ + "` array, plus 1", + " because index 0\\n // " + ], + [ + "Delete the slot where the moved ", + "value was stored\\n " + ], + [ + ");\\n\\n // Delete the index for the deleted slot\\n delete ", + "set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev " + ], + [ + "4\\\"", + ", as implemented by the " + ], + [ + "or\\n * ", + "throw on failure) are also supported, non-reverting calls are assumed to " + ], + [ + "\\n * types", + ".\\n *\\n * Sets " + ], + [ + "cannot be changed ", + "except through a xref:" + ], + [ + "version` is ", + "specified " + ], + [ + "meaning of `", + "name` and `" + ], + [ + ");\\n\\n if (address(uint160(prevOwnershipPacked)) != ", + "from) revert TransferFromIncorrectOwner();\\n\\n " + ], + [ + "it to zero", + ". To increase and decrease " + ], + [ + "// solhint-disable-next-line avoid-low-level-calls, avoid-call-value", + "\\n (bool success, ) = recipient.call{ value: amount " + ], + [ + "JSON RPC ", + "method" + ], + [ + "Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the ", + "token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n */\\ninterface IERC20Permit {\\n /**\\n * @dev Sets `value` as the allowance of `spender` " + ], + [ + ".\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator\\n ) internal pure returns (uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0))\\n prod0 := mul(x, y)\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1 == 0) {\\n return prod0 / denominator;\\n }\\n\\n // Make sure the result is less than 2^256. Also prevents denominator == 0.\\n require(denominator > prod1);\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator)\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder)\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function.\\n uint256 twos = denominator & (~denominator + 1);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1)\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step.\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator,\\n Rounding rounding\\n ", + ") internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> 2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= 10**64) {\\n value /= 10**64;\\n result += 64;\\n }\\n if (value >= 10**32) {\\n value /= 10**32;\\n result += 32;\\n }\\n if (value >= 10**16) {\\n value /= 10**16;\\n result += 16;\\n }\\n if (value >= 10**8) {\\n value /= 10**8;\\n result += 8;\\n }\\n if (value >= 10**4) {\\n value /= 10**4;\\n result += 4;\\n }\\n if (value >= 10**2) {\\n value /= 10**2;\\n result += 2;\\n }\\n if (value >= 10**1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log256(value);\\n return result + (rounding == Rounding.Up && 1 << (" + ], + [ + "hashing and sign", + "ing of typed structured " + ], + [ + "Sets {decimals} to a value other than the default one of 18", + ".\\n *\\n * WARNING: This function should only be called from the constructor. Most" + ], + [ + " is very ", + "generic, and " + ], + [ + "learn", + "::upgrad" + ], + [ + "_currentIndex != end", + ") revert(" + ], + [ + "DefaultRoyalty(address ", + "receiver, uint96 feeNumerator" + ], + [ + "chain id to ", + "protect against replay attack" + ], + [ + "bytes32 digest = _hashTypedDataV4(", + "keccak256(abi.encode(" + ], + [ + ", i.e. the ", + "name of the DApp" + ], + [ + "prettier-ignore\\n if iszero(", + "temp) { break " + ], + [ + "// Store", + "s the " + ], + [ + "SwapTokens", + "Threshold" + ], + [ + " or the ", + "protocol" + ], + [ + "auxiliary data for `owner`. (e.g. number of whitelist mint slots used).\\n */\\n function _getAux(address owner) internal view returns (uint64) {\\n return ", + "uint64" + ], + [ + "https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator", + "[EIP 712]" + ], + [ + "} 1 {} {\\n ", + "str := sub(str" + ], + [ + "mapping(address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping(bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev ", + "Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _check" + ], + [ + "(_packedOwnerships[index]);\\n }\\n\\n /**\\n * @dev ", + "Initializes the ownership slot minted at `index` for efficiency purposes.\\n */\\n function _initializeOwnershipAt(uint256 index" + ], + [ + "spendAllowance(account, _msgSender(), ", + "amount);\\n " + ], + [ + "from rightmost digit to ", + "leftmost digit.\\n // The following is essentially a do-while loop that also handles the zero case.\\n // " + ], + [ + "For branchless setting of the `nextInitialized` flag", + ".\\n assembly {\\n // " + ], + [ + ".length;\\n uint256 totalHashes = proofFlags.length;\\n\\n // Check proof validity.\\n require(leavesLen + proof", + ".length - 1 == totalHashes, \\\"MerkleProof: invalid multiproof\\\");\\n\\n // The xxxPos values are \\\"pointers\\\" to the next value to consume in each array. All accesses are done using\\n // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \\\"pop\\\".\\n bytes32[] memory hashes = new bytes32[](totalHashes);\\n uint256 leafPos = 0;\\n uint256 hashPos = 0;\\n uint256 proofPos = 0;\\n // At each step, we compute the next hash using two values:\\n // - a value from the \\\"main queue\\\". If not all leaves have been consumed, we get the next leaf, otherwise we\\n // get the next hash.\\n // - depending on the flag, either another " + ], + [ + "root hash by traversing the tree up from the leaves. The root is rebuilt by\\n // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the\\n // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of\\n // the merkle tree.\\n uint256 leavesLen = leaves", + ".length;\\n uint256 totalHashes = proofFlags.length;\\n\\n // Check proof validity.\\n require(leavesLen + proof.length - 1 == totalHashes, \\\"MerkleProof: invalid multiproof\\\");\\n\\n // The xxxPos values are \\\"pointers\\\" to the next value to consume in each array. All accesses are done using\\n // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \\\"pop\\\".\\n bytes32[] memory hashes = new bytes32[](totalHashes);\\n uint256 leafPos = 0;\\n uint256 hashPos = 0;\\n uint256 proofPos = 0;\\n // At each step, we compute the next hash using two values:\\n // - a value from the \\\"main queue\\\". If not all leaves have been consumed, we get the next leaf, otherwise we\\n // get the next hash.\\n // - depending on the flag, either another " + ], + [ + "`keccak256(bytes(\\\"", + "Transfer(address,address,uint256)\\\"))" + ], + [ + "amask", + ".io/guide/sign" + ], + [ + "\\\"v", + "4\\\", as implemented by the " + ], + [ + "uint256 packed = _packedOwnerships[", + "curr]" + ], + [ + " packed = _packedOwnerships[--", + "curr]" + ], + [ + ");\\n\\n // The nested ifs save around 20+ gas over a compound boolean condition", + ".\\n " + ], + [ + " as possible ", + "while still properly updating" + ], + [ + "address signer = ECDSA.recover(digest", + ", signature" + ], + [ + ");\\n\\n if (approvalCheck) {\\n // The nested ifs save around 20+ gas over a compound boolean condition", + ".\\n " + ], + [ + "),\\n \\\" is missing role \\\",\\n Strings.", + "toHexString(uint256(role), 32)\\n )\\n )\\n );\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role" + ], + [ + "prettier-ignore\\n for { let temp := ", + "value " + ], + [ + "ApprovalForAll} event.\\n */\\n function _setApprovalForAll(\\n address owner,\\n address operator,\\n bool approved", + "\\n ) internal virtual {\\n require(" + ], + [ + "BITPOS_START_TIMESTAMP) | flags`.\\n result := ", + "or(owner, or(" + ], + [ + "`nextInitialized` flag set if `quantity` equals 1.\\n */\\n function _nextInitializedFlag(uint256 quantity", + ") private pure returns (uint256 result) {\\n // " + ], + [ + ";\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\\n * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\\n * by default, it can be overridden in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return ", + "''" + ], + [ + "ASCII index of the '0' character is 48", + ".\\n mstore8(" + ], + [ + ";\\n uint256 index = end - quantity;\\n do {\\n ", + "if (!_checkContractOnERC721Received(address(0), to, index" + ], + [ + "(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only check isContract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata, string memory errorMessage) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage", + ");\\n }\\n }\\n}\\n\"" + ], + [ + "[hashed ", + "struct], " + ], + [ + "\\n * applications that interact with token contracts will not expect", + "\\n * {decimals} to ever change, and may work incorrectly if it does" + ], + [ + "end;\\n }\\n _afterTokenTransfers(address(0), to, startTokenId, quantity);\\n }\\n\\n /**\\n * @dev Mint", + "s `quantity` tokens and transfers them to `to`.\\n *\\n * This function is intended for efficient minting only during contract creation.\\n *\\n * It emits only one {ConsecutiveTransfer} as defined in\\n * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309),\\n * instead of a sequence of {Transfer} event(s).\\n *\\n * Calling this function outside of contract creation WILL make your contract\\n * non-compliant with the ERC721 standard.\\n * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309\\n * {ConsecutiveTransfer} event is only permissible during contract creation.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `quantity` must be greater than 0.\\n *\\n * Emits a {ConsecutiveTransfer} event.\\n */\\n function _mintERC2309" + ], + [ + "isOperatorFilte", + "red" + ], + [ + "AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(", + "AddressSet storage set, address value) internal returns (bool) {\\n return _add(" + ], + [ + " of primitive", + "\\n * types.\\n *\\n * Sets " + ], + [ + "as efficient", + " as possible while still properly updating" + ], + [ + "The implementation of the ", + "domain separator was designed to be " + ], + [ + "name`: ", + "the user readable " + ], + [ + "safeApprove ", + "should only be called when setting " + ], + [ + ";\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev ", + "Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(" + ], + [ + "set values\\n ", + "bytes32[] _values" + ], + [ + "abi.encode` and `", + "keccak256" + ], + [ + "is not fe", + "asible" + ], + [ + "add(Set storage set, bytes32 value) private returns (bool) {\\n ", + "if (!_contains(set, value" + ], + [ + " and parameter ", + "caches" + ], + [ + "signed via ", + "ECDSA" + ], + [ + "(uint256 tokenId)\\n private\\n view\\n returns (uint256 ", + "approvedAddressSlot, address approvedAddress)\\n {\\n " + ], + [ + "one in\\n // the ", + "array, and then remove the last element (" + ], + [ + "Set type with\\n // bytes32 ", + "values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as " + ], + [ + "version`: ", + "the current major " + ], + [ + "they need in their ", + "contracts using a " + ], + [ + "abstract_data_type", + ")[sets]" + ], + [ + "values on the set. O(1", + ").\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length" + ], + [ + "value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n ", + "set._indexes[value] = set._values.length" + ], + [ + "hash can be used together with {", + "ECDSA-recover} to " + ], + [ + "ing to obtain the ", + "message digest that is then " + ], + [ + "implementation in Solidity ", + "is not feasible" + ], + [ + "{IERC20-approve}, and its ", + "usage is discourag" + ], + [ + "around the\\n // ", + "underlying Set.\\n // This means that we can only create new " + ], + [ + "html[`eth_sign", + "TypedDataV4` in " + ], + [ + "Initializes the domain separator", + " and parameter caches" + ], + [ + "name of the signing domain", + ", i.e. the name of the DApp" + ], + [ + ")) {\\n set._values", + ".push(value);\\n // The " + ], + [ + "keccak256(\\\"Mail", + "(address to,string " + ], + [ + "means a value ", + "is not in the set.\\n " + ], + [ + "ing-smart", + "-contracts.adoc[" + ], + [ + "ing-data.", + "html[`eth_signTypedDataV4` in " + ], + [ + "EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct ", + "Set {\\n // Storage of " + ], + [ + "such a generic ", + "implementation in Solidity is not feasible" + ], + [ + "SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token", + "\\n * contract returns false). Tokens that return no value (and instead revert " + ], + [ + "(\\r\\n address tokenA,\\r\\n address ", + "tokenB" + ], + [ + "AddressSet\\n\\n struct ", + "AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(" + ], + [ + "AddressSet) are just wrappers ", + "around the\\n // underlying Set.\\n // This means that we can only create new " + ], + [ + "domain separator ({_", + "domainSeparatorV4}) that is used " + ], + [ + "domain separator for the current ", + "chain" + ], + [ + "copyEntries", + "Of" + ], + [ + "copyExisting", + "Entries" + ], + [ + " = valueIndex - 1;\\n uint256 lastIndex = ", + "set._values.length - 1" + ], + [ + "be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract", + ",\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc" + ], + [ + "Equivalent to contains(set, value", + ")\\n // To delete an element from the _values array " + ], + [ + "s on an event", + "ual fork" + ], + [ + "thus this contract does not ", + "implement the encoding itself. Protocol" + ], + [ + "NOTE: This contract implements the ", + "version of the encoding known as " + ], + [ + "set._values.pop(", + ");\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev " + ], + [ + "{\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic ", + "Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as " + ], + [ + "Set storage set, bytes32 value) private view returns (bool) {\\n return ", + "set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of " + ], + [ + "keccak256(bytes(mail", + "Contents))" + ], + [ + "UintSet storage set, uint256 index) internal view returns (uint256) {\\n return ", + "uint256(_at(set._inner, index" + ], + [ + "UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(", + "UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(" + ], + [ + "These parameters ", + "cannot be changed except through a xref:" + ], + [ + "returns the hash of the fully ", + "encoded EIP712 message " + ], + [ + "hashTypedDataV4(bytes32 structHash", + ") internal view virtual returns (" + ], + [ + "https://eips.ethereum.org/EIPS/eip-712[EIP 712]", + " is a standard for " + ], + [ + "encoding specified in the EIP", + " is very generic, and " + ], + [ + "valueIndex = set._indexes[value", + "];\\n\\n if (valueIndex != 0" + ], + [ + "final step of the encod", + "ing to obtain the message digest that is then " + ], + [ + "message. For example", + ":" + ], + [ + "Returns true if the value is in the set. O(1).\\n */\\n function _contains(", + "Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of " + ], + [ + "\"TOKEN: Max Transaction ", + "Limit\"" + ], + [ + "\"TOKEN: This account cannot send tokens until trading is ", + "enabled\"" + ], + [ + "Whenever possible, use {", + "safeIncreaseAllowance} " + ], + [ + "docs.met", + "amask.io/guide/sign" + ], + [ + "combination of `", + "abi.encode` and `keccak256" + ], + [ + "Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value", + ")" + ], + [ + "(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes memory _data\\n ) private returns (bool) {\\n try ERC721A__IERC721Receiver(to).onERC721Received(_msgSenderERC721A(), from, tokenId, _data) returns (", + "\\n bytes4 retval\\n ) {\\n return retval == " + ], + [ + "into a single 256bit ", + "word" + ], + [ + "obtain the signer of a ", + "message. For example:" + ], + [ + "https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct", + "[hashed struct], " + ], + [ + "contract implements the EIP 712 ", + "domain separator ({_domainSeparatorV4}) that is used " + ], + [ + "Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the ", + "value" + ], + [ + "set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev ", + "Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value)" + ], + [ + "EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * ", + "EnumerableSet.AddressSet private my" + ], + [ + "Given an already ", + "https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], " + ], + [ + "Library for managing\\n * https://", + "en.wikipedia.org/wiki/Set_(" + ], + [ + "scheme, and the ", + "final step of the encoding to obtain the message digest that is then " + ], + [ + "Deprecated. This function has issues ", + "similar to the ones found " + ], + [ + "or when resetting ", + "it to zero. To increase and decrease " + ], + [ + "Position of the value in the `values", + "` array, plus 1 because index 0\\n // " + ], + [ + "Move the last value to the index where the ", + "value to delete is" + ], + [ + "uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _", + "add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value" + ], + [ + "have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - ", + "Elements are " + ], + [ + "in O(1), we swap the element to delete with the last ", + "one in\\n // the array, and then remove the last element (" + ], + [ + "Delete the slot where the moved value was stored\\n ", + "set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev " + ], + [ + "or\\n * throw on failure) are also supported, non-reverting calls are assumed to ", + "be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc" + ], + [ + "meaning of `name` and `", + "version` is specified " + ], + [ + ".\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator\\n ) internal pure returns (uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0))\\n prod0 := mul(x, y)\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1 == 0) {\\n return prod0 / denominator;\\n }\\n\\n // Make sure the result is less than 2^256. Also prevents denominator == 0.\\n require(denominator > prod1);\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator)\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder)\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function.\\n uint256 twos = denominator & (~denominator + 1);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1)\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step.\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator,\\n Rounding rounding\\n ) internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> 2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= 10**64) {\\n value /= 10**64;\\n result += 64;\\n }\\n if (value >= 10**32) {\\n value /= 10**32;\\n result += 32;\\n }\\n if (value >= 10**16) {\\n value /= 10**16;\\n result += 16;\\n }\\n if (value >= 10**8) {\\n value /= 10**8;\\n result += 8;\\n }\\n if (value >= 10**4) {\\n value /= 10**4;\\n result += 4;\\n }\\n if (value >= 10**2) {\\n value /= 10**2;\\n result += 2;\\n }\\n if (value >= 10**1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log256(value);\\n return result + (rounding == Rounding.Up && 1 << (", + "result * 8" + ], + [ + "hashing and signing of typed structured ", + "data" + ], + [ + "Sets {decimals} to a value other than the default one of 18.\\n *\\n * WARNING: This function should only be called from the constructor. Most", + "\\n * applications that interact with token contracts will not expect\\n * {decimals} to ever change, and may work incorrectly if it does" + ], + [ + "learn::upgrad", + "ing-smart-contracts.adoc[" + ], + [ + "chain id to protect against replay attack", + "s on an eventual fork" + ], + [ + "For branchless setting of the `nextInitialized` flag.\\n assembly {\\n // ", + "`(quantity == 1" + ], + [ + "\\\"v4\\\", as implemented by the ", + "JSON RPC method" + ], + [ + " of primitive\\n * types.\\n *\\n * Sets ", + "have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are " + ], + [ + "The implementation of the domain separator was designed to be ", + "as efficient as possible while still properly updating" + ], + [ + "name`: the user readable ", + "name of the signing domain, i.e. the name of the DApp" + ], + [ + "safeApprove should only be called when setting ", + "an initial allowance" + ], + [ + ";\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(", + "Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value" + ], + [ + "version`: the current major ", + "version of the signing domain" + ], + [ + "they need in their contracts using a ", + "combination of `abi.encode` and `keccak256" + ], + [ + "abstract_data_type)[sets]", + " of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are " + ], + [ + "value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length", + ";\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value" + ], + [ + "hash can be used together with {ECDSA-recover} to ", + "obtain the signer of a message. For example:" + ], + [ + ")) {\\n set._values.push(value);\\n // The ", + "value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value" + ], + [ + "keccak256(\\\"Mail(address to,string ", + "contents)\\\")," + ], + [ + "ing-data.html[`eth_signTypedDataV4` in ", + "MetaMask" + ], + [ + "EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of ", + "set values\\n bytes32[] _values" + ], + [ + "SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert ", + "or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc" + ], + [ + "AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new ", + "EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values" + ], + [ + "Equivalent to contains(set, value)\\n // To delete an element from the _values array ", + "in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (" + ], + [ + "thus this contract does not implement the encoding itself. Protocol", + "s need to implement the type-specific " + ], + [ + "NOTE: This contract implements the version of the encoding known as ", + "\\\"v4\\\", as implemented by the JSON RPC method" + ], + [ + "{\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as ", + "AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values" + ], + [ + "UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(", + "set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value)" + ] + ] + } +} \ No newline at end of file