parameter (or

            (or

              (or (unit %default)

                  (or (nat %mint) (pair %oracle_callback string (pair timestamp nat))))

              (or (timestamp %ready_sale)

                  (or (unit %register_fomo)

                      (list %reveal_token_metadata (pair (nat %token_id)

                                                        (map %token_info string bytes))))))

            (or

              (or

                (pair %set_fomo_register_time (int %fomo_register_duration_minutes)

                                              (timestamp %fomo_register_start_time))

                (or (address %update_admin)

                    (list %update_blacklist (or (address %add_address)

                                               (address %remove_address)))))

              (or

                (or (pair %update_metadata (string %k) (bytes %v))

                    (list %upgrade_token_metadata (pair (nat %token_id)

                                                       (map %token_info string bytes))))

                (or (list %voucher_early_deployer address)

                    (list %voucher_fa2_callback (pair

                                                 (pair %request (address %owner)

                                                                (nat %token_id))

                                                 (nat %balance)))))));

storage (pair

          (pair

            (pair

              (pair (address %admin)

                    (pair (nat %base_index) (big_map %blacklist address unit)))

              (pair (pair (address %collaborator) (address %fa2))

                    (pair (mutez %fomo_price) (int %fomo_register_duration_minutes))))

            (pair

              (pair

                (pair (timestamp %fomo_register_start_time)

                      (int %fomo_sale_duration_minutes))

                (pair (timestamp %fomo_sale_start_time) (nat %fomo_supply)))

              (pair (pair (big_map %fomos address unit) (nat %max_mint))

                    (pair (nat %max_mint_wallet) (nat %max_supply)))))

          (pair

            (pair

              (pair (pair (big_map %metadata string bytes) (nat %mint_index))

                    (pair (big_map %mint_meta address (pair (nat %amount) (nat %level)))

                          (nat %n_minted)))

              (pair (pair (address %oracle) (bool %oracle_callback_expected))

                    (pair (string %placeholder_ipfs_path) (mutez %price))))

            (pair

              (pair (pair (string %provenance_hash) (int %public_sale_duration_minutes))

                    (pair (timestamp %public_sale_end_time)

                          (timestamp %public_sale_start_time)))

              (pair (pair (address %voucher_fa2) (bool %voucher_fa2_callback_expected))

                    (pair (nat %voucher_supply) (nat %voucher_token_id))))));

code { UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { DROP ;

                   NIL operation ;

                   SENDER ;

                   CONTRACT unit ;

                   IF_NONE { PUSH int 94 ; FAILWITH } {} ;

                   AMOUNT ;

                   UNIT ;

                   TRANSFER_TOKENS ;

                   CONS }

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       GET 3 ;

                       GET 3 ;

                       NOW ;

                       COMPARE ;

                       GE ;

                       IF

                         { SWAP ; DUP ; DUG 2 ; GET 5 ; GET 3 ; NOW ; COMPARE ; LE }

                         { PUSH bool False } ;

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

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 5 ;

                       GET 4 ;

                       NOW ;

                       COMPARE ;

                       LT ;

                       IF

                         { DUP ;

                           PUSH nat 1 ;

                           COMPARE ;

                           EQ ;

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

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           CAR ;

                           CAR ;

                           GET 5 ;

                           AMOUNT ;

                           COMPARE ;

                           EQ ;

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

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           CAR ;

                           GET 5 ;

                           CAR ;

                           SENDER ;

                           MEM ;

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

                           SWAP ;

                           DUP ;

                           GET 9 ;

                           SWAP ;

                           DUP ;

                           DUG 3 ;

                           CAR ;

                           GET 3 ;

                           GET 4 ;

                           ADD ;

                           PUSH nat 1 ;

                           DUP 4 ;

                           GET 3 ;

                           CAR ;

                           GET 4 ;

                           ADD ;

                           COMPARE ;

                           LE ;

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

                           SWAP ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           UNPAIR ;

                           NONE unit ;

                           SENDER ;

                           UPDATE ;

                           PAIR ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           SWAP }

                         { SWAP ;

                           DUP ;

                           DUG 2 ;

                           CAR ;

                           CAR ;

                           CAR ;

                           GET 4 ;

                           SENDER ;

                           MEM ;

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

                           DUP ;

                           PUSH nat 0 ;

                           COMPARE ;

                           LT ;

                           IF

                             { SWAP ; DUP ; DUG 2 ; CAR ; GET 5 ; CDR ; SWAP ; DUP ; DUG 2 ; COMPARE ; LE }

                             { PUSH bool False } ;

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

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           CAR ;

                           GET 8 ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           DUP 4 ;

                           GET 3 ;

                           CAR ;

                           GET 4 ;

                           ADD ;

                           COMPARE ;

                           LE ;

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

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           GET 3 ;

                           GET 6 ;

                           AMOUNT ;

                           EDIV ;

                           IF_NONE { PUSH int 200 ; FAILWITH } {} ;

                           CAR ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           COMPARE ;

                           EQ ;

                           IF

                             { PUSH mutez 1 ;

                               DUP ;

                               DUP 4 ;

                               GET 3 ;

                               GET 6 ;

                               EDIV ;

                               IF_NONE { PUSH int 201 ; FAILWITH } {} ;

                               CAR ;

                               DUP 4 ;

                               GET 3 ;

                               GET 6 ;

                               AMOUNT ;

                               EDIV ;

                               IF_NONE { PUSH int 200 ; FAILWITH } {} ;

                               CAR ;

                               MUL ;

                               MUL ;

                               AMOUNT ;

                               COMPARE ;

                               EQ }

                             { PUSH bool False } ;

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

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           GET 3 ;

                           CAR ;

                           GET 3 ;

                           SENDER ;

                           MEM ;

                           IF

                             { SWAP ;

                               DUP ;

                               DUG 2 ;

                               GET 3 ;

                               CAR ;

                               GET 3 ;

                               SENDER ;

                               GET ;

                               IF_NONE { PUSH int 206 ; FAILWITH } {} ;

                               CDR ;

                               LEVEL ;

                               COMPARE ;

                               GT ;

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

                               SWAP ;

                               DUP ;

                               DUG 2 ;

                               CAR ;

                               GET 7 ;

                               SWAP ;

                               DUP ;

                               DUG 2 ;

                               DUP 4 ;

                               GET 3 ;

                               CAR ;

                               GET 3 ;

                               SENDER ;

                               GET ;

                               IF_NONE { PUSH int 208 ; FAILWITH } {} ;

                               CAR ;

                               ADD ;

                               COMPARE ;

                               LE ;

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

                               SWAP ;

                               UNPAIR ;

                               SWAP ;

                               UNPAIR ;

                               UNPAIR ;

                               UNPAIR ;

                               SWAP ;

                               UNPAIR ;

                               DUP ;

                               SENDER ;

                               DUP ;

                               DUG 2 ;

                               GET ;

                               IF_NONE { PUSH int 209 ; FAILWITH } {} ;

                               DUP ;

                               CAR ;

                               DUP 10 ;

                               ADD ;

                               UPDATE 1 ;

                               SOME ;

                               SWAP ;

                               UPDATE ;

                               DUP ;

                               SENDER ;

                               DUP ;

                               DUG 2 ;

                               GET ;

                               IF_NONE { PUSH int 210 ; FAILWITH } {} ;

                               LEVEL ;

                               UPDATE 2 ;

                               SOME ;

                               SWAP ;

                               UPDATE ;

                               PAIR ;

                               SWAP ;

                               PAIR ;

                               PAIR ;

                               PAIR ;

                               SWAP ;

                               PAIR ;

                               SWAP }

                             { SWAP ;

                               UNPAIR ;

                               SWAP ;

                               UNPAIR ;

                               UNPAIR ;

                               UNPAIR ;

                               SWAP ;

                               UNPAIR ;

                               LEVEL ;

                               DUP 8 ;

                               PAIR ;

                               SOME ;

                               SENDER ;

                               UPDATE ;

                               PAIR ;

                               SWAP ;

                               PAIR ;

                               PAIR ;

                               PAIR ;

                               SWAP ;

                               PAIR ;

                               SWAP } } ;

                       NIL operation ;

                       DUP 3 ;

                       CAR ;

                       CAR ;

                       GET 3 ;

                       CAR ;

                       CONTRACT unit ;

                       IF_NONE { PUSH int 215 ; FAILWITH } {} ;

                       PUSH mutez 1 ;

                       PUSH nat 4 ;

                       PUSH mutez 1 ;

                       AMOUNT ;

                       EDIV ;

                       IF_NONE { PUSH int 214 ; FAILWITH } {} ;

                       CAR ;

                       EDIV ;

                       IF_NONE { PUSH int 214 ; FAILWITH } { CAR } ;

                       MUL ;

                       UNIT ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       DUP 3 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       CAR ;

                       CONTRACT unit ;

                       IF_NONE { PUSH int 216 ; FAILWITH } {} ;

                       PUSH mutez 1 ;

                       PUSH nat 4 ;

                       PUSH mutez 1 ;

                       AMOUNT ;

                       EDIV ;

                       IF_NONE { PUSH int 214 ; FAILWITH } {} ;

                       CAR ;

                       EDIV ;

                       IF_NONE { PUSH int 214 ; FAILWITH } { CAR } ;

                       MUL ;

                       AMOUNT ;

                       SUB ;

                       UNIT ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       PUSH nat 0 ;

                       DUP ;

                       DUP 3 ;

                       COMPARE ;

                       GT ;

                       LOOP { DUP 5 ;

                              GET 3 ;

                              CAR ;

                              CAR ;

                              CDR ;

                              NIL string ;

                              PUSH nat 0 ;

                              DUP 3 ;

                              COMPARE ;

                              EQ ;

                              IF { PUSH string "0" ; CONS } {} ;

                              PUSH nat 0 ;

                              DUP 3 ;

                              COMPARE ;

                              GT ;

                              LOOP { PUSH (map nat string) { Elt 0 "0" ;

                                             Elt 1 "1" ;

                                             Elt 2 "2" ;

                                             Elt 3 "3" ;

                                             Elt 4 "4" ;

                                             Elt 5 "5" ;

                                             Elt 6 "6" ;

                                             Elt 7 "7" ;

                                             Elt 8 "8" ;

                                             Elt 9 "9" } ;

                                     PUSH nat 10 ;

                                     DUP 4 ;

                                     EDIV ;

                                     IF_NONE { PUSH int 48 ; FAILWITH } { CDR } ;

                                     GET ;

                                     IF_NONE { PUSH int 48 ; FAILWITH } {} ;

                                     CONS ;

                                     PUSH nat 10 ;

                                     DIG 2 ;

                                     EDIV ;

                                     IF_NONE { PUSH int 49 ; FAILWITH } { CAR } ;

                                     SWAP ;

                                     PUSH nat 0 ;

                                     DUP 3 ;

                                     COMPARE ;

                                     GT } ;

                              SWAP ;

                              DROP ;

                              DIG 3 ;

                              DUP 6 ;

                              CAR ;

                              CAR ;

                              GET 3 ;

                              CDR ;

                              CONTRACT %mint (pair (pair address nat)

                                                   (pair nat (map string bytes))) ;

                              IF_NONE { PUSH int 252 ; FAILWITH } {} ;

                              PUSH mutez 0 ;

                              EMPTY_MAP string bytes ;

                              DIG 4 ;

                              CONCAT ;

                              DUP 9 ;

                              GET 3 ;

                              GET 5 ;

                              CONCAT ;

                              PACK ;

                              SOME ;

                              PUSH string "" ;

                              UPDATE ;

                              DIG 7 ;

                              DUP ;

                              CAR ;

                              CAR ;

                              CAR ;

                              GET 3 ;

                              SWAP ;

                              DUP ;

                              DUG 9 ;

                              GET 3 ;

                              CAR ;

                              CAR ;

                              CDR ;

                              ADD ;

                              PAIR ;

                              PUSH nat 1 ;

                              SENDER ;

                              PAIR ;

                              PAIR ;

                              TRANSFER_TOKENS ;

                              CONS ;

                              DUG 2 ;

                              DIG 4 ;

                              UNPAIR ;

                              SWAP ;

                              UNPAIR ;

                              UNPAIR ;

                              UNPAIR ;

                              UNPAIR ;

                              SWAP ;

                              PUSH nat 1 ;

                              ADD ;

                              SWAP ;

                              PAIR ;

                              PAIR ;

                              PAIR ;

                              PAIR ;

                              SWAP ;

                              PAIR ;

                              DUP ;

                              CAR ;

                              GET 8 ;

                              SWAP ;

                              DUP ;

                              DUG 6 ;

                              GET 3 ;

                              CAR ;

                              CAR ;

                              CDR ;

                              COMPARE ;

                              GT ;

                              IF

                                { DIG 4 ;

                                  UNPAIR ;

                                  SWAP ;

                                  UNPAIR ;

                                  UNPAIR ;

                                  UNPAIR ;

                                  CAR ;

                                  PUSH nat 1 ;

                                  SWAP ;

                                  PAIR ;

                                  PAIR ;

                                  PAIR ;

                                  PAIR ;

                                  SWAP ;

                                  PAIR ;

                                  DUG 4 }

                                {} ;

                              DIG 4 ;

                              UNPAIR ;

                              SWAP ;

                              UNPAIR ;

                              UNPAIR ;

                              UNPAIR ;

                              SWAP ;

                              UNPAIR ;

                              SWAP ;

                              PUSH nat 1 ;

                              ADD ;

                              SWAP ;

                              PAIR ;

                              SWAP ;

                              PAIR ;

                              PAIR ;

                              PAIR ;

                              SWAP ;

                              PAIR ;

                              DUG 4 ;

                              PUSH nat 1 ;

                              ADD ;

                              DUP ;

                              DUP 3 ;

                              COMPARE ;

                              GT } ;

                       DROP 2 ;

                       SWAP ;

                       DROP }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 3 ;

                       GET 3 ;

                       CAR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

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

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 3 ;

                       GET 3 ;

                       CDR ;

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

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       CAR ;

                       PUSH bool False ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       DUP ;

                       DUG 2 ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       UNPAIR ;

                       CAR ;

                       DIG 6 ;

                       CAR ;

                       GET 8 ;

                       DIG 6 ;

                       GET 4 ;

                       EDIV ;

                       IF_NONE { PUSH int 102 ; FAILWITH } { CDR } ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       DUP ;

                       GET 3 ;

                       CAR ;

                       CAR ;

                       CDR ;

                       PUSH nat 0 ;

                       COMPARE ;

                       EQ ;

                       IF

                         { DUP ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           UNPAIR ;

                           UNPAIR ;

                           CAR ;

                           DIG 5 ;

                           CAR ;

                           GET 8 ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           PAIR ;

                           PAIR ;

                           SWAP ;

                           PAIR }

                         {} ;

                       NIL operation } } }

             { IF_LEFT

                 { SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   SENDER ;

                   COMPARE ;

                   EQ ;

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

                   SWAP ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   CDR ;

                   DUP 6 ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   DUP ;

                   DUG 2 ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   CAR ;

                   DIG 5 ;

                   PUSH int 60 ;

                   DIG 7 ;

                   CAR ;

                   GET 3 ;

                   CAR ;

                   CDR ;

                   MUL ;

                   ADD ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   DUP ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   CDR ;

                   DUP 6 ;

                   GET 5 ;

                   GET 4 ;

                   PUSH int 60 ;

                   DIG 7 ;

                   GET 5 ;

                   CAR ;

                   CDR ;

                   MUL ;

                   ADD ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   CAR ;

                   PUSH bool True ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   DUP ;

                   GET 3 ;

                   GET 3 ;

                   CAR ;

                   CONTRACT %get (pair string

                                       (contract (pair string (pair timestamp nat)))) ;

                   IF_NONE { PUSH int 116 ; FAILWITH } {} ;

                   NIL operation ;

                   SWAP ;

                   PUSH mutez 0 ;

                   SELF_ADDRESS ;

                   CONTRACT %oracle_callback (pair string (pair timestamp nat)) ;

                   IF_NONE { PUSH int 117 ; FAILWITH } {} ;

                   PUSH string "XTZ-USD" ;

                   PAIR ;

                   TRANSFER_TOKENS ;

                   CONS }

                 { IF_LEFT

                     { DROP ;

                       DUP ;

                       CAR ;

                       CAR ;

                       CAR ;

                       GET 4 ;

                       SENDER ;

                       MEM ;

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

                       DUP ;

                       CAR ;

                       GET 5 ;

                       CAR ;

                       SENDER ;

                       MEM ;

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

                       DUP ;

                       CAR ;

                       GET 3 ;

                       CAR ;

                       CAR ;

                       NOW ;

                       COMPARE ;

                       GE ;

                       IF

                         { DUP ;

                           CAR ;

                           GET 3 ;

                           CAR ;

                           CAR ;

                           PUSH int 60 ;

                           DUP 3 ;

                           CAR ;

                           CAR ;

                           GET 6 ;

                           MUL ;

                           ADD ;

                           NOW ;

                           COMPARE ;

                           LE }

                         { PUSH bool False } ;

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

                       UNPAIR ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       SWAP ;

                       UNPAIR ;

                       UNPAIR ;

                       PUSH (option unit) (Some Unit) ;

                       SENDER ;

                       UPDATE ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       NIL operation }

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

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

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET 5 ;

                       GET 4 ;

                       NOW ;

                       COMPARE ;

                       GE ;

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

                       NIL operation ;

                       DUP 3 ;

                       CAR ;

                       CAR ;

                       GET 3 ;

                       CDR ;

                       CONTRACT %update_token_metadata (list (pair nat (map string bytes))) ;

                       IF_NONE { PUSH int 167 ; FAILWITH } {} ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       TRANSFER_TOKENS ;

                       CONS } } } }

         { IF_LEFT

             { IF_LEFT

                 { SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CAR ;