parameter (or

            (or

              (or

                (pair %buy (nat %amount)

                           (pair (bytes %extra)

                                 (pair (bytes %project_id) (option %recipient address))))

                (bytes %delete_project))

              (or (pair %eject_fa2 (address %new_admin) (bytes %project_id))

                  (list %reveal (pair (bytes %cid)

                                     (pair (list %proof bytes)

                                           (pair (nat %purchase_id) (nat %token_id)))))))

            (or

              (or (address %set_admin)

                  (pair %set_project (bytes %merkle_root)

                                     (pair (bytes %metadata)

                                           (pair (nat %n_tokens)

                                                 (pair (bytes %project_id)

                                                       (pair %sale (address %contract)

                                                                   (bytes %id)))))))

              (or (mutez %set_reveal_fee)

                  (or (address %set_revealer)

                      (pair %update_fa2_metadata (bytes %metadata) (bytes %project_id))))));

storage (pair (address %administrator)

              (pair (nat %next_purchase_id)

                    (pair

                      (big_map %projects bytes

                                         (pair (address %creator)

                                               (pair (address %fa2)

                                                     (pair (bytes %merkle_root)

                                                           (pair (nat %n_sold)

                                                                 (pair (nat %n_tokens)

                                                                       (pair %sale

                                                                         (address %contract)

                                                                         (bytes %id))))))))

                      (pair

                        (big_map %purchase_queue nat

                                                 (pair (address %fa2)

                                                       (pair (nat %iteration)

                                                             (pair (mutez %price)

                                                                   (pair

                                                                     (bytes %project_id)

                                                                     (address %recipient))))))

                        (pair (mutez %reveal_fee) (address %revealer))))));

code { LAMBDA

         (pair (pair address (pair bytes (pair address nat))) (list operation))

         (pair unit (list operation))

         { UNPAIR ;

           SWAP ;

           DUP 2 ;

           CAR ;

           CONTRACT %mint (pair (bytes %metadata_uri)

                                (pair (address %recipient) (nat %token_id))) ;

           IF_NONE { PUSH int 55 ; FAILWITH } {} ;

           PUSH mutez 0 ;

           DIG 3 ;

           DUP ;

           GET 6 ;

           SWAP ;

           DUP ;

           GET 5 ;

           SWAP ;

           GET 3 ;

           PAIR 3 ;

           TRANSFER_TOKENS ;

           CONS ;

           UNIT ;

           PAIR } ;

       SWAP ;

       LAMBDA

         (pair unit

               (pair address

                     (pair nat

                           (pair

                             (big_map bytes

                                      (pair address

                                            (pair address

                                                  (pair bytes

                                                        (pair nat

                                                              (pair nat

                                                                    (pair address bytes)))))))

                             (pair

                               (big_map nat

                                        (pair address

                                              (pair nat

                                                    (pair mutez (pair bytes address)))))

                               (pair mutez address))))))

         (pair unit

               (pair address

                     (pair nat

                           (pair

                             (big_map bytes

                                      (pair address

                                            (pair address

                                                  (pair bytes

                                                        (pair nat

                                                              (pair nat

                                                                    (pair address bytes)))))))

                             (pair

                               (big_map nat

                                        (pair address

                                              (pair nat

                                                    (pair mutez (pair bytes address)))))

                               (pair mutez address))))))

         { CDR ;

           DUP ;

           CAR ;

           SENDER ;

           COMPARE ;

           EQ ;

           IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;

           UNIT ;

           PAIR } ;

       SWAP ;

       UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { DIG 3 ;

               DROP ;

               IF_LEFT

                 { PUSH nat 0 ;

                   DUP 2 ;

                   CAR ;

                   COMPARE ;

                   GT ;

                   IF {} { PUSH string "ZERO_AMOUNT" ; FAILWITH } ;

                   DUP 2 ;

                   GET 5 ;

                   DUP 2 ;

                   GET 5 ;

                   GET ;

                   IF_NONE { PUSH string "INVALID_PROJECT" ; FAILWITH } {} ;

                   PUSH int 0 ;

                   DUP 2 ;

                   GET 7 ;

                   DUP 3 ;

                   GET 9 ;

                   SUB ;

                   COMPARE ;

                   GT ;

                   IF {} { PUSH string "SOLD_OUT" ; FAILWITH } ;

                   DUP 2 ;

                   CAR ;

                   DUP 2 ;

                   GET 7 ;

                   DUP 3 ;

                   GET 9 ;

                   SUB ;

                   ISNAT ;

                   IF_NONE { PUSH int 156 ; FAILWITH } {} ;

                   DUP ;

                   DUP 3 ;

                   COMPARE ;

                   LE ;

                   IF { DROP } { SWAP ; DROP } ;

                   DUP 3 ;

                   CAR ;

                   DUP 5 ;

                   GET 9 ;

                   MUL ;

                   DUP ;

                   AMOUNT ;

                   COMPARE ;

                   GE ;

                   IF {} { PUSH string "MISSING_REVEAL_FEE" ; FAILWITH } ;

                   NIL operation ;

                   DUP 6 ;

                   GET 10 ;

                   CONTRACT unit ;

                   IF_NONE { PUSH int 160 ; FAILWITH } {} ;

                   DUP 3 ;

                   UNIT ;

                   TRANSFER_TOKENS ;

                   CONS ;

                   DUP 2 ;

                   AMOUNT ;

                   SUB_MUTEZ ;

                   IF_NONE { PUSH int 161 ; FAILWITH } {} ;

                   DUP 6 ;

                   CAR ;

                   PUSH nat 1 ;

                   DUP 3 ;

                   MUL ;

                   EDIV ;

                   IF_NONE { PUSH int 162 ; FAILWITH } {} ;

                   CAR ;

                   SENDER ;

                   DUP 8 ;

                   GET 6 ;

                   IF_NONE {} { SWAP ; DROP } ;

                   DUP 8 ;

                   CAR ;

                   PUSH nat 0 ;

                   DUP 2 ;

                   INT ;

                   GT ;

                   LOOP { DUP 11 ;

                          DUP ;

                          GET 7 ;

                          DUP 5 ;

                          DUP 13 ;

                          GET 5 ;

                          DUP 8 ;

                          DUP 6 ;

                          DUP 15 ;

                          GET 7 ;

                          ADD ;

                          DUP 15 ;

                          GET 3 ;

                          PAIR 5 ;

                          SOME ;

                          DUP 4 ;

                          DIG 14 ;

                          GET 3 ;

                          ADD ;

                          UPDATE ;

                          UPDATE 7 ;

                          DUG 10 ;

                          PUSH nat 1 ;

                          ADD ;

                          DUP ;

                          DUP 3 ;

                          COMPARE ;

                          GT } ;

                   DROP 2 ;

                   DIG 8 ;

                   DUP ;

                   GET 5 ;

                   DUP ;

                   DUP 11 ;

                   GET 5 ;

                   DUP ;

                   DUG 2 ;

                   GET ;

                   IF_NONE { PUSH int 177 ; FAILWITH } {} ;

                   DUP ;

                   GET 7 ;

                   DUP 13 ;

                   CAR ;

                   ADD ;

                   UPDATE 7 ;

                   SOME ;

                   SWAP ;

                   UPDATE ;

                   UPDATE 5 ;

                   DUP ;

                   GET 3 ;

                   DUP 10 ;

                   CAR ;

                   ADD ;

                   UPDATE 3 ;

                   DUG 8 ;

                   DUP 7 ;

                   GET 11 ;

                   CONTRACT %execute_sale (pair (bytes %sale_id)

                                                (pair (address %buyer)

                                                      (pair (nat %req_amount)

                                                            (pair (nat %net_amount)

                                                                  (bytes %extra))))) ;

                   IF_NONE { PUSH int 181 ; FAILWITH } {} ;

                   DUP 5 ;

                   DUP 2 ;

                   DUP 6 ;

                   DUP 12 ;

                   GET 3 ;

                   DUP 11 ;

                   DUP 14 ;

                   CAR ;

                   SENDER ;

                   DUP 15 ;

                   GET 12 ;

                   PAIR 5 ;

                   DIG 4 ;

                   DROP ;

                   DIG 4 ;

                   DROP ;

                   DIG 4 ;

                   DROP ;

                   DIG 4 ;

                   DROP ;

                   DIG 4 ;

                   DROP ;

                   DIG 4 ;

                   DROP ;

                   DIG 4 ;

                   DROP ;

                   DIG 4 ;

                   DROP ;

                   DIG 4 ;

                   DROP ;

                   DIG 5 ;

                   DROP ;

                   TRANSFER_TOKENS ;

                   CONS }

                 { DIG 2 ;

                   DROP ;

                   DUP 2 ;

                   GET 5 ;

                   DUP 2 ;

                   GET ;

                   IF_NONE

                     { DROP }

                     { PUSH nat 0 ;

                       DUP 2 ;

                       GET 7 ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "SALE_STARTED" ; FAILWITH } ;

                       CAR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF {} { PUSH string "ONLY_CREATOR" ; FAILWITH } ;

                       SWAP ;

                       DUP ;

                       GET 5 ;

                       NONE (pair address

                                  (pair address

                                        (pair bytes

                                              (pair nat (pair nat (pair address bytes)))))) ;

                       DIG 3 ;

                       UPDATE ;

                       UPDATE 5 } ;

                   NIL operation } }

             { IF_LEFT

                 { DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   DUP 2 ;

                   GET 5 ;

                   DUP 2 ;

                   CDR ;

                   GET ;

                   IF_NONE { PUSH string "INVALID_PROJECT" ; FAILWITH } {} ;

                   SENDER ;

                   DUP 2 ;

                   CAR ;

                   COMPARE ;

                   EQ ;

                   IF {} { PUSH string "ONLY_CREATOR" ; FAILWITH } ;

                   GET 3 ;

                   CONTRACT %set_admin address ;

                   IF_NONE { PUSH int 262 ; FAILWITH } {} ;

                   NIL operation ;

                   SWAP ;

                   PUSH mutez 0 ;

                   DIG 3 ;

                   CAR ;

                   TRANSFER_TOKENS ;

                   CONS }

                 { NIL operation ;

                   DUP 2 ;

                   ITER { DUP 4 ;

                          GET 7 ;

                          DUP 2 ;

                          GET 5 ;

                          GET ;

                          IF_NONE { PUSH string "INVALID_PURCHASE" ; FAILWITH } {} ;

                          DUP 5 ;

                          GET 5 ;

                          DUP 2 ;

                          GET 7 ;

                          GET ;

                          IF_NONE { PUSH string "INVALID_PROJECT" ; FAILWITH } {} ;

                          LAMBDA

                            (pair bytes (list bytes))

                            bytes

                            { DUP ;

                              CAR ;

                              BLAKE2B ;

                              SWAP ;

                              CDR ;

                              ITER { DUP ;

                                     DUP 3 ;

                                     COMPARE ;

                                     LT ;

                                     IF

                                       { SWAP ; CONCAT ; BLAKE2B }

                                       { CONCAT ; BLAKE2B } } } ;

                          DUP 4 ;

                          GET 3 ;

                          DUP 5 ;

                          CAR ;

                          DUP 6 ;

                          GET 6 ;

                          PAIR ;

                          DUP 5 ;

                          GET 3 ;

                          PAIR ;

                          PACK ;

                          PAIR ;

                          EXEC ;

                          DUP 2 ;

                          GET 5 ;

                          COMPARE ;

                          EQ ;

                          IF {} { PUSH string "INVALID_MERKLE_PROOF" ; FAILWITH } ;

                          DUP 8 ;

                          DUP 4 ;

                          GET 6 ;

                          DUP 4 ;

                          GET 8 ;

                          DUP 6 ;

                          CAR ;

                          DUP 5 ;

                          GET 3 ;

                          PAIR 4 ;

                          SWAP ;

                          DIG 5 ;

                          DIG 2 ;

                          PAIR ;

                          EXEC ;

                          CDR ;

                          DIG 7 ;

                          DIG 7 ;

                          DIG 7 ;

                          DIG 7 ;

                          DIG 4 ;

                          DIG 7 ;

                          DIG 7 ;

                          DIG 7 ;

                          DIG 3 ;

                          DUP 4 ;

                          GET 6 ;

                          DIG 3 ;

                          GET 5 ;

                          DIG 3 ;

                          GET 3 ;

                          PAIR 3 ;

                          EMIT %sale (pair (address %fa2)

                                           (pair (mutez %price) (nat %token_id))) ;

                          CONS ;

                          SWAP ;

                          DIG 3 ;

                          DUP ;

                          GET 7 ;

                          NONE (pair address

                                     (pair nat (pair mutez (pair bytes address)))) ;

                          DIG 3 ;

                          GET 5 ;

                          UPDATE ;

                          UPDATE 7 ;

                          DUG 2 } ;

                   SWAP ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP } } }

         { IF_LEFT

             { IF_LEFT

                 { DIG 3 ;

                   DROP ;

                   DIG 2 ;

                   UNIT ;

                   SWAP ;

                   DIG 3 ;

                   DIG 2 ;

                   PAIR ;

                   EXEC ;

                   CDR ;

                   SWAP ;

                   UPDATE 1 ;

                   NIL operation }

                 { SELF_ADDRESS ;

                   PUSH nat 0 ;

                   PUSH nat 16 ;

                   DUP 4 ;

                   GET 7 ;

                   SIZE ;

                   COMPARE ;

                   EQ ;

                   IF {} { PUSH string "INVALID_PROJECT_ID" ; FAILWITH } ;

                   DUP 4 ;

                   GET 5 ;

                   DUP 4 ;

                   GET 7 ;

                   GET ;

                   IF_NONE

                     { SWAP ;

                       DROP ;

                       NIL operation ;

                       EMPTY_BIG_MAP nat (pair nat (map string bytes)) ;

                       EMPTY_BIG_MAP (pair address (pair address nat)) unit ;

                       EMPTY_BIG_MAP string bytes ;

                       DUP 6 ;

                       GET 3 ;

                       SOME ;

                       PUSH string "" ;

                       UPDATE ;

                       EMPTY_BIG_MAP nat address ;

                       SELF_ADDRESS ;

                       PAIR 5 ;

                       PUSH mutez 0 ;

                       NONE key_hash ;

                       CREATE_CONTRACT { parameter (or

                                                     (or

                                                       (pair %balance_of

                                                         (list %requests (pair

                                                                          (address %owner)

                                                                          (nat %token_id)))

                                                         (contract %callback (list (pair

                                                                                   (pair %request

                                                                                     (address %owner)

                                                                                     (nat %token_id))

                                                                                   (nat %balance)))))

                                                       (or

                                                         (pair %mint

                                                           (bytes %metadata_uri)

                                                           (pair (address %recipient)

                                                                 (nat %token_id)))

                                                         (address %set_admin)))

                                                     (or

                                                       (map %set_metadata string bytes)

                                                       (or

                                                         (list %transfer (pair

                                                                          (address %from_)

                                                                          (list %txs (pair

                                                                                      (address %to_)

                                                                                      (pair

                                                                                        (nat %token_id)

                                                                                        (nat %amount))))))

                                                         (list %update_operators (or

                                                                                  (pair %add_operator

                                                                                    (address %owner)

                                                                                    (pair

                                                                                      (address %operator)

                                                                                      (nat %token_id)))

                                                                                  (pair %remove_operator

                                                                                    (address %owner)

                                                                                    (pair

                                                                                      (address %operator)

                                                                                      (nat %token_id)))))))) ;

                                         storage (pair (address %administrator)

                                                       (pair

                                                         (big_map %ledger nat address)

                                                         (pair

                                                           (big_map %metadata string

                                                                              bytes)

                                                           (pair

                                                             (big_map %operators

                                                               (pair (address %owner)

                                                                     (pair

                                                                       (address %operator)

                                                                       (nat %token_id)))

                                                               unit)

                                                             (big_map %token_metadata

                                                               nat

                                                               (pair (nat %token_id)

                                                                     (map %token_info

                                                                       string

                                                                       bytes))))))) ;

                                         code { UNPAIR ;

                                                IF_LEFT

                                                  { IF_LEFT

                                                      { NIL (pair (pair address nat) nat) ;

                                                        DUP 2 ;

                                                        CAR ;

                                                        ITER { DUP 4 ;

                                                               GET 3 ;

                                                               DUP 2 ;

                                                               CDR ;

                                                               MEM ;

                                                               IF

                                                                 {}

                                                                 { PUSH string "FA2_TOKEN_UNDEFINED" ;

                                                                   FAILWITH } ;

                                                               SWAP ;

                                                               DUP 2 ;

                                                               CAR ;

                                                               DUP 5 ;

                                                               GET 3 ;

                                                               DUP 4 ;

                                                               CDR ;

                                                               GET ;

                                                               IF_NONE

                                                                 { PUSH int 112 ;

                                                                   FAILWITH }

                                                                 {} ;

                                                               COMPARE ;

                                                               EQ ;

                                                               IF

                                                                 { PUSH nat 1 }

                                                                 { PUSH nat 0 } ;

                                                               DIG 2 ;

                                                               PAIR ;

                                                               CONS } ;

                                                        NIL operation ;

                                                        DIG 2 ;

                                                        CDR ;

                                                        PUSH mutez 0 ;

                                                        DIG 3 ;

                                                        NIL (pair (pair address nat) nat) ;

                                                        SWAP ;

                                                        ITER { CONS } ;

                                                        TRANSFER_TOKENS ;

                                                        CONS }

                                                      { IF_LEFT

                                                          { DUP 2 ;

                                                            CAR ;

                                                            SENDER ;

                                                            COMPARE ;

                                                            EQ ;

                                                            IF

                                                              {}

                                                              { PUSH string "FA2_ONLY_ADMIN" ;

                                                                FAILWITH } ;

                                                            DUP 2 ;

                                                            GET 3 ;

                                                            DUP 2 ;

                                                            GET 4 ;

                                                            MEM ;

                                                            IF

                                                              { PUSH string "FA2_TOKEN_ALREADY_EXISTS" ;

                                                                FAILWITH }

                                                              {} ;

                                                            SWAP ;

                                                            DUP ;

                                                            GET 3 ;

                                                            DUP 3 ;

                                                            GET 3 ;

                                                            SOME ;

                                                            DUP 4 ;

                                                            GET 4 ;

                                                            UPDATE ;

                                                            UPDATE 3 ;

                                                            DUP ;

                                                            GET 8 ;

                                                            EMPTY_MAP string bytes ;

                                                            DUP 4 ;

                                                            CAR ;

                                                            SOME ;

                                                            PUSH string "" ;

                                                            UPDATE ;

                                                            DUP 4 ;

                                                            GET 4 ;

                                                            PAIR ;

                                                            SOME ;

                                                            DIG 3 ;

                                                            GET 4 ;

                                                            UPDATE ;

                                                            UPDATE 8 }

                                                          { DUP 2 ;

                                                            CAR ;

                                                            SENDER ;

                                                            COMPARE ;

                                                            EQ ;

                                                            IF

                                                              {}

                                                              { PUSH string "FA2_NOT_ADMIN" ;

                                                                FAILWITH } ;

                                                            UPDATE 1 } ;

                                                        NIL operation } }

                                                  { IF_LEFT

                                                      { DUP 2 ;

                                                        CAR ;

                                                        SENDER ;

                                                        COMPARE ;

                                                        EQ ;

                                                        IF

                                                          {}

                                                          { PUSH string "FA2_NOT_ADMIN" ;

                                                            FAILWITH } ;

                                                        DUP ;

                                                        ITER { DIG 2 ;

                                                               DUP ;

                                                               GET 5 ;

                                                               DUP 3 ;

                                                               CDR ;

                                                               SOME ;

                                                               DIG 3 ;

                                                               CAR ;

                                                               UPDATE ;

                                                               UPDATE 5 ;

                                                               SWAP } ;

                                                        DROP }

                                                      { IF_LEFT

                                                          { DUP ;

                                                            ITER { DUP ;

                                                                   CDR ;

                                                                   ITER { DUP 4 ;

                                                                          GET 3 ;

                                                                          DUP 2 ;

                                                                          GET 3 ;

                                                                          MEM ;

                                                                          IF

                                                                            {}

                                                                            { PUSH string "FA2_TOKEN_UNDEFINED" ;

                                                                              FAILWITH } ;

                                                                          SENDER ;

                                                                          DUP 3 ;

                                                                          CAR ;

                                                                          COMPARE ;

                                                                          EQ ;

                                                                          IF

                                                                            { PUSH bool True }

                                                                            { DUP 4 ;

                                                                              GET 7 ;

                                                                              DUP 2 ;

                                                                              GET 3 ;

                                                                              SENDER ;

                                                                              DUP 5 ;

                                                                              CAR ;

                                                                              PAIR 3 ;

                                                                              MEM } ;

                                                                          IF

                                                                            {}

                                                                            { PUSH string "FA2_NOT_OPERATOR" ;

                                                                              FAILWITH } ;

                                                                          PUSH nat 0 ;

                                                                          DUP 2 ;

                                                                          GET 4 ;

                                                                          COMPARE ;

                                                                          GT ;

                                                                          IF

                                                                            { PUSH nat 1 ;

                                                                              DUP 2 ;

                                                                              GET 4 ;

                                                                              COMPARE ;

                                                                              EQ ;

                                                                              IF

                                                                                { DUP 2 ;

                                                                                  CAR ;

                                                                                  DUP 5 ;

                                                                                  GET 3 ;

                                                                                  DUP 3 ;

                                                                                  GET 3 ;

                                                                                  GET ;

                                                                                  IF_NONE

                                                                                    { PUSH int 87 ;

                                                                                      FAILWITH }

                                                                                    {} ;

                                                                                  COMPARE ;

                                                                                  EQ }

                                                                                { PUSH bool False } ;

                                                                              IF

                                                                                {}

                                                                                { PUSH string "FA2_INSUFFICIENT_BALANCE" ;

                                                                                  FAILWITH } ;

                                                                              DIG 3 ;

                                                                              DUP ;

                                                                              GET 3 ;

                                                                              DUP 3 ;

                                                                              CAR ;

                                                                              SOME ;

                                                                              DIG 3 ;

                                                                              GET 3 ;

                                                                              UPDATE ;

                                                                              UPDATE 3 ;

                                                                              DUG 2 }

                                                                            { DROP } } ;

                                                                   DROP } ;

                                                            DROP }

                                                          { DUP ;

                                                            ITER { IF_LEFT

                                                                     { SENDER ;

                                                                       DUP 2 ;

                                                                       CAR ;

                                                                       COMPARE ;

                                                                       EQ ;

                                                                       IF

                                                                         {}

                                                                         { PUSH string "FA2_NOT_OWNER" ;

                                                                           FAILWITH } ;

                                                                       DIG 2 ;

                                                                       DUP ;

                                                                       GET 7 ;

                                                                       PUSH (option unit) (Some Unit) ;

                                                                       DIG 3 ;

                                                                       UPDATE ;

                                                                       UPDATE 7 ;

                                                                       SWAP }

                                                                     { SENDER ;

                                                                       DUP 2 ;

                                                                       CAR ;

                                                                       COMPARE ;

                                                                       EQ ;

                                                                       IF

                                                                         {}

                                                                         { PUSH string "FA2_NOT_OWNER" ;

                                                                           FAILWITH } ;

                                                                       DIG 2 ;

                                                                       DUP ;

                                                                       GET 7 ;

                                                                       NONE unit ;

                                                                       DIG 3 ;

                                                                       UPDATE ;

                                                                       UPDATE 7 ;

                                                                       SWAP } } ;

                                                            DROP } } ;

                                                    NIL operation } ;

                                                PAIR } ;

                                         view "get_metadata" string bytes

                                               { UNPAIR ;

                                                 SWAP ;

                                                 GET 5 ;

                                                 SWAP ;

                                                 GET ;

                                                 IF_NONE

                                                   { PUSH int 133 ; FAILWITH }

                                                   {} } } ;

                       DIG 2 ;

                       SWAP ;

                       CONS ;

                       SWAP ;

                       DUG 2 ;

                       DUP 3 ;

                       SENDER ;

                       PAIR ;

                       EMIT %fa2_created (pair (address %creator) (address %fa2)) ;

                       CONS }

                     { SWAP ;

                       DROP ;

                       SWAP ;

                       DROP ;

                       DUP ;