parameter (or

            (or

              (or (pair %configure (option %fa2 address) (option %pause bool))

                  (pair %mint (nat %n_tokens) (nat %sale_id)))

              (or

                (list %reveal_metadata (pair (nat %token_id)

                                            (map %token_info string bytes)))

                (pair %update_admin address bool)))

            (pair %update_sale nat

                               (option (pair

                                        (pair (pair (nat %allowance) (timestamp %date))

                                              (int %duration)

                                              (option %pass (pair

                                                             (pair (bool %burn)

                                                                   (address %kt))

                                                             (nat %token_id))))

                                        (mutez %price)))));

storage (pair

          (pair

            (pair

              (pair (set %admin address) (big_map %allowances (pair address nat) nat))

              (address %fa2)

              (bytes %ipfs_template_uri))

            (pair (nat %max_supply) (set %minted nat))

            (bool %paused)

            (bytes %provenance))

          (big_map %sales nat

                          (pair

                            (pair (pair (nat %allowance) (timestamp %date))

                                  (int %duration)

                                  (option %pass (pair (pair (bool %burn) (address %kt))

                                                     (nat %token_id))))

                            (mutez %price)))

          (map %shares address nat));

code { NIL operation ;

       PUSH string "Access denied" ;

       PUSH string "Wrong funds amount" ;

       LAMBDA

         (pair (pair (pair address address) nat address) nat)

         operation

         { UNPAIR ;

           UNPAIR ;

           UNPAIR ;

           DIG 2 ;

           UNPAIR ;

           SWAP ;

           CONTRACT %transfer (list (pair (address %from_)

                                         (list %txs (pair (address %to_) (nat %token_id)

                                                         (nat %amount))))) ;

           IF_NONE { PUSH string "option is None" ; FAILWITH } {} ;

           PUSH mutez 0 ;

           NIL (pair address (list (pair address nat nat))) ;

           NIL (pair address nat nat) ;

           DIG 4 ;

           DIG 7 ;

           DIG 7 ;

           PAIR 3 ;

           CONS ;

           DIG 4 ;

           PAIR ;

           CONS ;

           TRANSFER_TOKENS } ;

       DIG 4 ;

       UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { DIG 2 ;

                   DIG 3 ;

                   DROP 2 ;

                   SWAP ;

                   DIG 2 ;

                   DUP 2 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   SENDER ;

                   MEM ;

                   IF { DROP } { FAILWITH } ;

                   DUP 2 ;

                   CAR ;

                   IF_NONE

                     {}

                     { SWAP ;

                       DUP ;

                       CDR ;

                       DUP 2 ;

                       CAR ;

                       CDR ;

                       DUP 3 ;

                       CAR ;

                       CAR ;

                       CDR ;

                       CDR ;

                       DIG 4 ;

                       PAIR ;

                       DIG 3 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       PAIR ;

                       PAIR ;

                       PAIR } ;

                   SWAP ;

                   CDR ;

                   IF_NONE

                     {}

                     { SWAP ;

                       DUP ;

                       CDR ;

                       DUP 2 ;

                       CAR ;

                       CDR ;

                       CDR ;

                       CDR ;

                       DIG 3 ;

                       PAIR ;

                       DUP 3 ;

                       CAR ;

                       CDR ;

                       CAR ;

                       PAIR ;

                       DIG 2 ;

                       CAR ;

                       CAR ;

                       PAIR ;

                       PAIR } ;

                   SWAP }

                 { DIG 4 ;

                   DROP ;

                   SWAP ;

                   PUSH string "Sale paused" ;

                   DUP 2 ;

                   CAR ;

                   CDR ;

                   CDR ;

                   CAR ;

                   NOT ;

                   IF { DROP } { FAILWITH } ;

                   PUSH string "Sold out" ;

                   DUP 2 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   CDR ;

                   SIZE ;

                   DUP 3 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   CAR ;

                   COMPARE ;

                   GT ;

                   IF { DROP } { FAILWITH } ;

                   DUP ;

                   CDR ;

                   CAR ;

                   DUP 3 ;

                   CDR ;

                   GET ;

                   IF_NONE { PUSH string "Sale not found" ; FAILWITH } {} ;

                   PUSH string "Sale Event Not started yet" ;

                   DUP 2 ;

                   CAR ;

                   CAR ;

                   CDR ;

                   NOW ;

                   COMPARE ;

                   GE ;

                   IF { DROP } { FAILWITH } ;

                   PUSH string "Sale Event has ended" ;

                   DUP 2 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   DUP 3 ;

                   CAR ;

                   CAR ;

                   CDR ;

                   ADD ;

                   NOW ;

                   COMPARE ;

                   LT ;

                   IF { DROP } { FAILWITH } ;

                   PUSH nat 0 ;

                   DUP 4 ;

                   CAR ;

                   COMPARE ;

                   GT ;

                   IF {} { PUSH string "Zero tokens to mint?" ; FAILWITH } ;

                   PUSH string "Mint amount too big" ;

                   DUP 3 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   CDR ;

                   SIZE ;

                   DUP 5 ;

                   CAR ;

                   ADD ;

                   DUP 4 ;

                   CAR ;

                   CDR ;

                   CAR ;

                   CAR ;

                   COMPARE ;

                   GE ;

                   IF { DROP } { FAILWITH } ;

                   DUP 2 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   SENDER ;

                   MEM ;

                   NOT ;

                   IF

                     { DUP 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       CDR ;

                       DUP 4 ;

                       CDR ;

                       SENDER ;

                       PAIR ;

                       GET ;

                       IF_NONE { DUP 3 ; CAR } { DUP 4 ; CAR ; ADD } ;

                       DUP 2 ;

                       CAR ;

                       CAR ;

                       CAR ;

                       SWAP ;

                       COMPARE ;

                       LE ;

                       IF {} { PUSH string "Allowance exceeded" ; FAILWITH } ;

                       DIG 4 ;

                       DUP 4 ;

                       CAR ;

                       DUP 3 ;

                       CDR ;

                       MUL ;

                       AMOUNT ;

                       COMPARE ;

                       EQ ;

                       IF { DROP } { FAILWITH } }

                     { DIG 4 ; DROP } ;

                   CAR ;

                   CDR ;

                   CDR ;

                   IF_NONE

                     { DIG 2 ; DROP ; DIG 2 }

                     { DIG 4 ;

                       DROP ;

                       NIL operation ;

                       DUP 2 ;

                       CAR ;

                       CAR ;

                       IF

                         { DUP 2 ;

                           CDR ;

                           DIG 2 ;

                           CAR ;

                           CDR ;

                           DUP 5 ;

                           CAR ;

                           PAIR ;

                           PUSH address "tz1burnburnburnburnburnburnburjAYjjX" ;

                           SENDER ;

                           PAIR ;

                           PAIR ;

                           PAIR ;

                           DIG 4 ;

                           SWAP ;

                           EXEC }

                         { DUP 2 ;

                           CDR ;

                           DIG 2 ;

                           CAR ;

                           CDR ;

                           PUSH nat 1 ;

                           PAIR ;

                           SENDER ;

                           SENDER ;

                           PAIR ;

                           PAIR ;

                           PAIR ;

                           DIG 4 ;

                           SWAP ;

                           EXEC } ;

                       CONS } ;

                   PUSH int 1 ;

                   DIG 3 ;

                   CAR ;

                   INT ;

                   PUSH int 1 ;

                   DUP 2 ;

                   DUP 2 ;

                   COMPARE ;

                   LE ;

                   LOOP { DUP ;

                          DUG 3 ;

                          DIP 3

                               { DROP ;

                                 DUP 2 ;

                                 CAR ;

                                 CDR ;

                                 CAR ;

                                 CAR ;

                                 DUP 3 ;

                                 CAR ;

                                 CDR ;

                                 CAR ;

                                 CDR ;

                                 EMPTY_MAP nat int ;

                                 PUSH nat 0 ;

                                 PUSH int 1 ;

                                 DIG 4 ;

                                 INT ;

                                 PUSH int 1 ;

                                 DUP 2 ;

                                 DUP 2 ;

                                 COMPARE ;

                                 LE ;

                                 LOOP { DUP ;

                                        DUG 3 ;

                                        DIP 3

                                             { DUP 4 ;

                                               DUP 2 ;

                                               ABS ;

                                               MEM ;

                                               IF

                                                 { DROP }

                                                 { DIG 2 ;

                                                   SWAP ;

                                                   DUP 3 ;

                                                   SWAP ;

                                                   SOME ;

                                                   SWAP ;

                                                   UPDATE ;

                                                   SWAP ;

                                                   PUSH nat 1 ;

                                                   ADD } } ;

                                        DUP 3 ;

                                        ADD ;

                                        DUP 2 ;

                                        DUP 2 ;

                                        COMPARE ;

                                        LE } ;

                                 DROP 3 ;

                                 DIG 2 ;

                                 DROP 2 ;

                                 DUP ;

                                 SIZE ;

                                 LEVEL ;

                                 PUSH nat 111147797 ;

                                 ADD ;

                                 EDIV ;

                                 IF_NONE { PUSH string "MOD by 0" ; FAILWITH } {} ;

                                 CDR ;

                                 GET ;

                                 IF_NONE { PUSH string "Wrong index" ; FAILWITH } {} ;

                                 ABS ;

                                 SWAP ;

                                 DUP 3 ;

                                 SENDER ;

                                 DUP 4 ;

                                 DUP 3 ;

                                 CAR ;

                                 CAR ;

                                 CDR ;

                                 CAR ;

                                 CONTRACT %mint (pair (address %target) (nat %token_id)

                                                      (map %token_info string bytes)) ;

                                 IF_NONE { PUSH int 1 ; FAILWITH } {} ;

                                 EMPTY_MAP string bytes ;

                                 PUSH bytes 0x050707000007070000070700000707000007070000070700000000 ;

                                 SOME ;

                                 PUSH string "*" ;

                                 UPDATE ;

                                 DUP 3 ;

                                 PUSH bytes 0x30 ;

                                 PUSH bool True ;

                                 LOOP { PUSH nat 0 ;

                                        DUP 3 ;

                                        COMPARE ;

                                        NEQ ;

                                        DUP ;

                                        IF

                                          { SWAP ;

                                            PUSH bytes 0x30313233343536373839 ;

                                            PUSH nat 1 ;

                                            PUSH nat 10 ;

                                            DUP 6 ;

                                            EDIV ;

                                            IF_NONE

                                              { PUSH string "MOD by 0" ; FAILWITH }

                                              {} ;

                                            CDR ;

                                            SLICE ;

                                            IF_NONE

                                              { PUSH string "SLICE" ; FAILWITH }

                                              {} ;

                                            CONCAT ;

                                            SWAP ;

                                            PUSH nat 10 ;

                                            DIG 3 ;

                                            EDIV ;

                                            IF_NONE

                                              { PUSH string "DIV by 0" ; FAILWITH }

                                              {} ;

                                            CAR ;

                                            DUG 2 }

                                          {} } ;

                                 PUSH int 1 ;

                                 DUP 2 ;

                                 SIZE ;

                                 SUB ;

                                 ABS ;

                                 DIG 2 ;

                                 DUP 2 ;

                                 COMPARE ;

                                 EQ ;

                                 IF

                                   { DROP }

                                   { PUSH nat 0 ;

                                     SLICE ;

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

                                 DIG 5 ;

                                 CAR ;

                                 CAR ;

                                 CDR ;

                                 CDR ;

                                 CONCAT ;

                                 SOME ;

                                 PUSH string "" ;

                                 UPDATE ;

                                 SWAP ;

                                 PUSH mutez 0 ;

                                 DIG 2 ;

                                 DIG 3 ;

                                 DIG 4 ;

                                 PAIR 3 ;

                                 TRANSFER_TOKENS ;

                                 CONS ;

                                 SWAP ;

                                 DUP 3 ;

                                 DUP ;

                                 CDR ;

                                 DUP 2 ;

                                 CAR ;

                                 CDR ;

                                 CDR ;

                                 DIG 5 ;

                                 CAR ;

                                 CDR ;

                                 CAR ;

                                 CDR ;

                                 DIG 4 ;

                                 PUSH bool True ;

                                 SWAP ;

                                 UPDATE ;

                                 DUP 4 ;

                                 CAR ;

                                 CDR ;

                                 CAR ;

                                 CAR ;

                                 PAIR ;

                                 PAIR ;

                                 DIG 2 ;

                                 CAR ;

                                 CAR ;

                                 PAIR ;

                                 PAIR ;

                                 SWAP } ;

                          DUP 3 ;

                          ADD ;

                          DUP 2 ;

                          DUP 2 ;

                          COMPARE ;

                          LE } ;

                   DROP 3 ;

                   DUP 2 ;

                   SWAP ;

                   AMOUNT ;

                   DIG 3 ;

                   CDR ;

                   CDR ;

                   DIG 2 ;

                   SWAP ;

                   ITER { UNPAIR ;

                          SWAP ;

                          PUSH nat 1000 ;

                          DUP 5 ;

                          EDIV ;

                          IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;

                          CAR ;

                          MUL ;

                          PUSH mutez 0 ;

                          DUP 2 ;

                          COMPARE ;

                          GT ;

                          IF

                            { DUG 2 ;

                              CONTRACT unit ;

                              IF_NONE { PUSH int 0 ; FAILWITH } {} ;

                              DIG 2 ;

                              UNIT ;

                              TRANSFER_TOKENS ;

                              CONS }

                            { DROP 2 } } ;

                   SWAP ;

                   DROP } }

             { DIG 2 ;

               DROP ;

               IF_LEFT

                 { DIG 4 ;

                   DROP ;

                   DIG 3 ;

                   DUP 3 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   SENDER ;

                   MEM ;

                   IF { DROP } { FAILWITH } ;

                   DIG 2 ;

                   PUSH mutez 0 ;

                   AMOUNT ;

                   COMPARE ;

                   EQ ;

                   IF { DROP } { FAILWITH } ;

                   DUP 2 ;

                   CAR ;

                   CAR ;

                   CDR ;

                   CAR ;

                   CONTRACT %update_token_metadata (list (pair (nat %token_id)

                                                              (map %token_info string

                                                                               bytes))) ;

                   IF_NONE { PUSH int 1 ; FAILWITH } {} ;

                   DIG 2 ;

                   NIL operation ;

                   DIG 2 ;

                   PUSH mutez 0 ;

                   DIG 4 ;

                   TRANSFER_TOKENS ;

                   CONS }

                 { DIG 2 ;

                   DROP ;

                   SWAP ;

                   DIG 2 ;

                   DUP 2 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   SENDER ;

                   MEM ;

                   IF { DROP } { FAILWITH } ;

                   DUP ;

                   DUP ;

                   CDR ;

                   DUP 2 ;

                   CAR ;

                   CDR ;

                   DUP 3 ;

                   CAR ;

                   CAR ;

                   CDR ;

                   DIG 3 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CDR ;

                   DIG 4 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   DIG 5 ;

                   UNPAIR ;

                   UPDATE ;

                   PAIR ;

                   PAIR ;

                   PAIR ;

                   PAIR ;

                   PUSH string "At least one admin is required" ;

                   PUSH nat 0 ;

                   DUP 3 ;

                   CAR ;

                   CAR ;

                   CAR ;

                   CAR ;

                   SIZE ;

                   COMPARE ;

                   GT ;

                   IF { DROP } { FAILWITH } ;

                   SWAP } } }

         { DIG 2 ;

           DIG 3 ;

           DROP 2 ;

           SWAP ;

           DIG 2 ;

           DUP 2 ;

           CAR ;

           CAR ;

           CAR ;

           CAR ;

           SENDER ;

           MEM ;

           IF { DROP } { FAILWITH } ;

           DUP ;

           DUP ;

           CDR ;

           CDR ;

           DIG 2 ;

           CDR ;

           CAR ;

           DIG 3 ;

           UNPAIR ;

           UPDATE ;

           PAIR ;

           SWAP ;

           CAR ;

           PAIR ;

           SWAP } ;

       PAIR }