parameter (or

            (or

              (pair %buy (nat %auction_id)

                         (pair (nat %amount)

                               (pair (nat %editions)

                                     (pair (option %condition_extra bytes)

                                           (pair (option %proxy_for address)

                                                 (map %referrers address nat))))))

              (or (nat %cancel_auction)

                  (pair %create_auction (pair %token (address %address) (nat %token_id))

                                        (pair

                                          (or %currency (address %fa12)

                                                        (or

                                                          (pair %fa2 (address %address)

                                                                     (nat %token_id))

                                                          (unit %tez)))

                                          (pair (nat %editions)

                                                (pair (timestamp %start_time)

                                                      (pair (timestamp %end_time)

                                                            (pair (nat %start_price)

                                                                  (pair (nat %end_price)

                                                                        (pair

                                                                          (map %shares

                                                                            address

                                                                            nat)

                                                                          (pair

                                                                            (nat %referral_bonus)

                                                                            (option %condition (pair

                                                                                                (address %address)

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

            (or (or (unit %default) (unit %delegate))

                (or (address %update_fee_sharing_registry)

                    (address %update_permission_module))));

storage (pair

          (pair

            (big_map %auctions nat

                               (pair (address %creator)

                                     (pair

                                       (pair %token (address %address) (nat %token_id))

                                       (pair

                                         (or %currency (address %fa12)

                                                       (or

                                                         (pair %fa2 (address %address)

                                                                    (nat %token_id))

                                                         (unit %tez)))

                                         (pair (nat %editions)

                                               (pair (timestamp %start_time)

                                                     (pair (timestamp %end_time)

                                                           (pair (nat %start_price)

                                                                 (pair (nat %end_price)

                                                                       (pair

                                                                         (map %shares

                                                                           address

                                                                           nat)

                                                                         (pair

                                                                           (nat %platform_fee)

                                                                           (pair

                                                                             (nat %referral_bonus)

                                                                             (option %condition (pair

                                                                                                 (address %address)

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

            (address %fee_sharing_registry))

          (pair (big_map %metadata string bytes)

                (pair (nat %next_auction_id) (address %permission_module))));

code { UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { SWAP ;

               DUP ;

               DUG 2 ;

               CAR ;

               CAR ;

               SWAP ;

               DUP ;

               DUG 2 ;

               CAR ;

               GET ;

               IF_NONE { PUSH int 224 ; FAILWITH } {} ;

               PUSH nat 1 ;

               DUP 3 ;

               GET 5 ;

               COMPARE ;

               GE ;

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

               DUP ;

               GET 9 ;

               NOW ;

               COMPARE ;

               GE ;

               IF { DUP ; GET 11 ; NOW ; COMPARE ; LE } { PUSH bool False } ;

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

               DUP ;

               GET 9 ;

               SWAP ;

               DUP ;

               DUG 2 ;

               GET 11 ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH int 231 ; FAILWITH } {} ;

               SWAP ;

               DUP ;

               GET 15 ;

               SWAP ;

               DUP ;

               DUG 3 ;

               GET 13 ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH int 230 ; FAILWITH } {} ;

               DUP 3 ;

               GET 9 ;

               NOW ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH int 234 ; FAILWITH } {} ;

               MUL ;

               EDIV ;

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

               SWAP ;

               DUP ;

               DUG 2 ;

               GET 13 ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH int 237 ; FAILWITH } {} ;

               DUP ;

               DUP 4 ;

               GET 3 ;

               COMPARE ;

               GE ;

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

               DUP 4 ;

               GET 6 ;

               UNIT ;

               VIEW "get_treasury" address ;

               IF_NONE { PUSH int 158 ; FAILWITH } {} ;

               DUP 5 ;

               CAR ;

               CDR ;

               DUP 5 ;

               GET 10 ;

               DIG 4 ;

               DUP ;

               GET 21 ;

               SWAP ;

               DUP ;

               DUG 6 ;

               GET 19 ;

               PAIR 3 ;

               VIEW "get_share_fee" (map address nat) ;

               IF_NONE { PUSH int 136 ; FAILWITH } {} ;

               DUP 4 ;

               GET 19 ;

               PUSH nat 0 ;

               DIG 2 ;

               DUP ;

               DUP ;

               DUG 4 ;

               ITER { DIG 2 ; SWAP ; CDR ; ADD ; SWAP } ;

               PUSH nat 0 ;

               DUP 8 ;

               GET 21 ;

               COMPARE ;

               EQ ;

               IF

                 { SWAP ;

                   DUP ;

                   DUG 2 ;

                   DIG 3 ;

                   SUB ;

                   ISNAT ;

                   IF_NONE { PUSH int 47 ; FAILWITH } {} ;

                   DUG 2 }

                 {} ;

               DUP 7 ;

               GET 17 ;

               ITER { DUP ;

                      CDR ;

                      DIG 3 ;

                      ADD ;

                      DUG 2 ;

                      SWAP ;

                      DUP ;

                      DUG 2 ;

                      SWAP ;

                      DUP ;

                      DUG 2 ;

                      CAR ;

                      MEM ;

                      IF

                        { SWAP ;

                          DUP ;

                          DUP 3 ;

                          CAR ;

                          DUP ;

                          DUG 2 ;

                          GET ;

                          IF_NONE { PUSH int 53 ; FAILWITH } {} ;

                          DIG 3 ;

                          CDR ;

                          ADD ;

                          SOME ;

                          SWAP ;

                          UPDATE }

                        { DUP ; DUG 2 ; CDR ; SOME ; DIG 2 ; CAR ; UPDATE } } ;

               DUP 3 ;

               DIG 2 ;

               ADD ;

               SWAP ;

               DUP ;

               DUP 6 ;

               MEM ;

               IF

                 { DUP ;

                   DUP 6 ;

                   DUP ;

                   DUG 2 ;

                   GET ;

                   IF_NONE { PUSH int 60 ; FAILWITH } {} ;

                   DUP 5 ;

                   ADD ;

                   SOME ;

                   SWAP ;

                   UPDATE }

                 { DUP 3 ; SOME ; DUP 6 ; UPDATE } ;

               PUSH nat 10000 ;

               DUP 3 ;

               COMPARE ;

               LE ;

               IF

                 {}

                 { PUSH string "WrongCondition: total_fee.value <= 10000" ; FAILWITH } ;

               SENDER ;

               DUP 9 ;

               GET 9 ;

               IF_NONE {} { SWAP ; DROP } ;

               DUP 9 ;

               GET 5 ;

               DUP 9 ;

               GET 7 ;

               DUP ;

               DUP 3 ;

               COMPARE ;

               LE ;

               IF { DROP } { SWAP ; DROP } ;

               DUP 9 ;

               GET 22 ;

               IF_NONE

                 { NIL operation }

                 { DUP ;

                   CAR ;

                   CONTRACT %enforce_conditions (list (pair

                                                       (pair (nat %amount)

                                                             (pair (address %claimer)

                                                                   (bytes %condition_id)))

                                                       (pair (address %creator)

                                                             (pair (option %extra bytes)

                                                                   (pair %token

                                                                     (address %address)

                                                                     (nat %token_id)))))) ;

                   IF_NONE { PUSH int 517 ; FAILWITH } {} ;

                   NIL operation ;

                   SWAP ;

                   PUSH mutez 0 ;

                   NIL (pair (pair nat (pair address bytes))

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

                   DUP 14 ;

                   GET 3 ;

                   DUP 16 ;

                   GET 7 ;

                   PAIR ;

                   DUP 15 ;

                   CAR ;

                   PAIR ;

                   DIG 5 ;

                   CDR ;

                   SENDER ;

                   PAIR ;

                   DUP 7 ;

                   PAIR ;

                   PAIR ;

                   CONS ;

                   TRANSFER_TOKENS ;

                   CONS } ;

               SWAP ;

               DUP ;

               DUG 2 ;

               DUP 10 ;

               MUL ;

               SWAP ;

               DUP 11 ;

               GET 3 ;

               CAR ;

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

                                             (list %txs (pair (address %to_)

                                                             (pair (nat %token_id)

                                                                   (nat %amount)))))) ;

               IF_NONE { PUSH int 305 ; FAILWITH } {} ;

               PUSH mutez 0 ;

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

               NIL (pair address (pair nat nat)) ;

               DUP 7 ;

               DUP 16 ;

               GET 3 ;

               CDR ;

               DUP 10 ;

               PAIR 3 ;

               CONS ;

               DUP 15 ;

               CAR ;

               PAIR ;

               CONS ;

               TRANSFER_TOKENS ;

               CONS ;

               SWAP ;

               DUP 11 ;

               GET 5 ;

               IF_LEFT

                 { PUSH nat 0 ;

                   DUP 7 ;

                   ITER { DUP ;

                          CDR ;

                          PUSH nat 10000 ;

                          SWAP ;

                          DUP 6 ;

                          MUL ;

                          EDIV ;

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

                          DUP ;

                          DIG 3 ;

                          ADD ;

                          DUG 2 ;

                          DUP ;

                          PUSH nat 0 ;

                          COMPARE ;

                          LT ;

                          IF

                            { DIG 5 ;

                              DUP 5 ;

                              CONTRACT %transfer (pair address (pair address nat)) ;

                              IF_NONE { PUSH int 460 ; FAILWITH } {} ;

                              PUSH mutez 0 ;

                              DIG 3 ;

                              DIG 4 ;

                              CAR ;

                              PAIR ;

                              SENDER ;

                              PAIR ;

                              TRANSFER_TOKENS ;

                              CONS ;

                              DUG 3 }

                            { DROP 2 } } ;

                   DUP ;

                   DUP 4 ;

                   SUB ;

                   DUP 4 ;

                   DUP 3 ;

                   COMPARE ;

                   LE ;

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

                   DUP ;

                   PUSH int 0 ;

                   COMPARE ;

                   LT ;

                   IF

                     { SWAP ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       DIG 4 ;

                       DROP ;

                       DIG 4 ;

                       DROP ;

                       DIG 4 ;

                       DROP ;

                       DIG 4 ;

                       DROP ;

                       DIG 4 ;

                       DROP ;

                       DIG 4 ;

                       DROP ;

                       DIG 4 ;

                       DROP ;

                       DUG 2 ;

                       CONTRACT %transfer (pair address (pair address nat)) ;

                       IF_NONE { PUSH int 460 ; FAILWITH } {} ;

                       PUSH mutez 0 ;

                       DIG 3 ;

                       ISNAT ;

                       IF_NONE { PUSH int 265 ; FAILWITH } {} ;

                       DUP 6 ;

                       CAR ;

                       PAIR ;

                       SENDER ;

                       PAIR ;

                       TRANSFER_TOKENS ;

                       CONS }

                     { DROP 4 ;

                       DIG 2 ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       DIG 2 ;

                       DROP ;

                       DIG 2 ;

                       DROP } }

                 { IF_LEFT

                     { PUSH nat 0 ;

                       NIL (pair address (pair nat nat)) ;

                       DUP 8 ;

                       ITER { DUP ;

                              CDR ;

                              PUSH nat 10000 ;

                              SWAP ;

                              DUP 7 ;

                              MUL ;

                              EDIV ;

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

                              DUP ;

                              DIG 4 ;

                              ADD ;

                              DUG 3 ;

                              DUP ;

                              PUSH nat 0 ;

                              COMPARE ;

                              LT ;

                              IF

                                { DIG 2 ; SWAP ; DUP 5 ; CDR ; DIG 3 ; CAR ; PAIR 3 ; CONS }

                                { DROP 2 } } ;

                       DUP 4 ;

                       DUP 3 ;

                       COMPARE ;

                       LE ;

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

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       DUP 5 ;

                       SUB ;

                       DUP ;

                       PUSH int 0 ;

                       COMPARE ;

                       LT ;

                       IF

                         { DIG 2 ;

                           DROP ;

                           DIG 3 ;

                           DROP ;

                           DIG 5 ;

                           DROP ;

                           DIG 5 ;

                           DROP ;

                           DIG 5 ;

                           DROP ;

                           DIG 5 ;

                           DROP ;

                           DIG 5 ;

                           DROP ;

                           DIG 5 ;

                           DROP ;

                           DIG 5 ;

                           DROP ;

                           ISNAT ;

                           IF_NONE { PUSH int 122 ; FAILWITH } {} ;

                           DUP 3 ;

                           CDR ;

                           DUP 7 ;

                           CAR ;

                           PAIR 3 ;

                           CONS }

                         { DROP ;

                           SWAP ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 4 ;

                           DROP ;

                           DIG 4 ;

                           DROP ;

                           DIG 4 ;

                           DROP ;

                           DIG 4 ;

                           DROP ;

                           DIG 4 ;

                           DROP ;

                           DIG 4 ;

                           DROP ;

                           DIG 4 ;

                           DROP } ;

                       DUG 2 ;

                       CAR ;

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

                                                     (list %txs (pair (address %to_)

                                                                     (pair

                                                                       (nat %token_id)

                                                                       (nat %amount)))))) ;

                       IF_NONE { PUSH int 394 ; FAILWITH } {} ;

                       PUSH mutez 0 ;

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

                       DIG 4 ;

                       SENDER ;

                       PAIR ;

                       CONS ;

                       TRANSFER_TOKENS ;

                       CONS }

                     { PUSH mutez 1 ;

                       AMOUNT ;

                       EDIV ;

                       IF_NONE { UNIT ; FAILWITH } {} ;

                       CAR ;

                       DUP 3 ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       COMPARE ;

                       GE ;

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

                       PUSH mutez 0 ;

                       DUP 8 ;

                       ITER { DUP ;

                              CDR ;

                              PUSH nat 10000 ;

                              SWAP ;

                              PUSH mutez 1 ;

                              DUP 8 ;

                              MUL ;

                              MUL ;

                              EDIV ;

                              IF_NONE { PUSH int 78 ; FAILWITH } {} ;

                              CAR ;

                              DUP ;

                              DIG 3 ;

                              ADD ;

                              DUG 2 ;

                              DUP ;

                              PUSH mutez 0 ;

                              COMPARE ;

                              LT ;

                              IF

                                { DIG 6 ;

                                  DIG 2 ;

                                  CAR ;

                                  CONTRACT unit ;

                                  IF_NONE { PUSH int 85 ; FAILWITH } {} ;

                                  DIG 2 ;

                                  UNIT ;

                                  TRANSFER_TOKENS ;

                                  CONS ;

                                  DUG 4 }

                                { DROP 2 } } ;

                       PUSH mutez 1 ;

                       DUP ;

                       DUP 3 ;

                       EDIV ;

                       IF_NONE { UNIT ; FAILWITH } {} ;

                       CAR ;

                       DUP 6 ;

                       SUB ;

                       ISNAT ;

                       IF_NONE { PUSH int 90 ; FAILWITH } {} ;

                       MUL ;

                       PUSH mutez 1 ;

                       DUP 6 ;

                       MUL ;

                       DUP 3 ;

                       COMPARE ;

                       LE ;

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

                       DUP ;

                       PUSH mutez 0 ;

                       COMPARE ;

                       LT ;

                       IF

                         { SWAP ;

                           DROP ;

                           DIG 4 ;

                           DUP 14 ;

                           CAR ;

                           CONTRACT unit ;

                           IF_NONE { PUSH int 98 ; FAILWITH } {} ;

                           DIG 2 ;

                           UNIT ;

                           TRANSFER_TOKENS ;

                           CONS ;

                           DUG 3 }

                         { DROP 2 } ;

                       DUP 3 ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       COMPARE ;

                       GT ;

                       IF

                         { SWAP ;

                           DROP ;

                           DIG 4 ;

                           DROP ;

                           DIG 4 ;

                           DROP ;

                           DIG 4 ;

                           DROP ;

                           DIG 4 ;

                           DROP ;

                           DIG 4 ;

                           DROP ;

                           DIG 4 ;

                           DROP ;

                           DIG 4 ;

                           DROP ;

                           DIG 2 ;

                           SENDER ;

                           CONTRACT unit ;

                           IF_NONE { PUSH int 319 ; FAILWITH } {} ;

                           PUSH mutez 1 ;

                           DIG 4 ;

                           DIG 4 ;

                           SUB ;

                           ISNAT ;

                           IF_NONE { PUSH int 322 ; FAILWITH } {} ;

                           MUL ;

                           UNIT ;

                           TRANSFER_TOKENS ;

                           CONS }

                         { DROP 3 ;

                           DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP } } } ;

               DIG 4 ;

               UNPAIR ;

               UNPAIR ;

               DUP ;

               DUP 8 ;

               CAR ;

               DUP ;

               DUG 2 ;

               GET ;

               IF_NONE { PUSH int 326 ; FAILWITH } {} ;

               DIG 6 ;

               DIG 7 ;

               GET 7 ;

               SUB ;

               ISNAT ;

               IF_NONE { PUSH int 326 ; FAILWITH } {} ;

               UPDATE 7 ;

               SOME ;

               SWAP ;

               UPDATE ;

               PAIR ;

               PAIR ;

               DUG 2 ;

               PUSH nat 0 ;

               DUP 4 ;

               CAR ;

               CAR ;

               DUP 4 ;

               CAR ;

               GET ;

               IF_NONE { PUSH int 329 ; FAILWITH } {} ;

               GET 7 ;

               COMPARE ;

               EQ ;

               IF

                 { DIG 2 ;

                   UNPAIR ;

                   UNPAIR ;

                   NONE (pair address

                              (pair (pair address nat)

                                    (pair (or address (or (pair address nat) unit))

                                          (pair nat

                                                (pair timestamp

                                                      (pair timestamp

                                                            (pair nat

                                                                  (pair nat

                                                                        (pair

                                                                          (map address

                                                                               nat)

                                                                          (pair nat

                                                                                (pair

                                                                                  nat

                                                                                  (option (pair

                                                                                           address

                                                                                           bytes))))))))))))) ;

                   DIG 5 ;

                   CAR ;

                   UPDATE ;

                   PAIR ;

                   PAIR ;

                   SWAP }

                 { SWAP ; DROP } }

             { IF_LEFT

                 { SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CAR ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   GET ;

                   IF_NONE { PUSH int 187 ; FAILWITH } {} ;

                   DUP ;

                   CAR ;

                   SENDER ;

                   COMPARE ;

                   EQ ;

                   IF { DROP ; PUSH bool True } { GET 11 ; NOW ; COMPARE ; GT } ;

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

                   SWAP ;

                   UNPAIR ;

                   UNPAIR ;

                   NONE (pair address

                              (pair (pair address nat)

                                    (pair (or address (or (pair address nat) unit))

                                          (pair nat

                                                (pair timestamp

                                                      (pair timestamp

                                                            (pair nat

                                                                  (pair nat

                                                                        (pair

                                                                          (map address

                                                                               nat)

                                                                          (pair nat

                                                                                (pair

                                                                                  nat

                                                                                  (option (pair

                                                                                           address

                                                                                           bytes))))))))))))) ;

                   DIG 4 ;

                   UPDATE ;

                   PAIR ;

                   PAIR }

                 { DUP ;

                   GET 7 ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   GET 9 ;

                   COMPARE ;

                   GT ;

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

                   PUSH int 2592000 ;

                   SWAP ;

                   DUP ;

                   GET 7 ;

                   SWAP ;

                   DUP ;

                   DUG 3 ;

                   GET 9 ;

                   SUB ;

                   COMPARE ;

                   LE ;

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

                   DUP ;

                   GET 13 ;

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   GET 11 ;

                   COMPARE ;

                   GT ;

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

                   SWAP ;

                   DUP ;

                   DUG 2 ;

                   CAR ;

                   CDR ;

                   UNIT ;

                   VIEW "get_management_fee" nat ;

                   IF_NONE { PUSH int 148 ; FAILWITH } {} ;

                   PUSH nat 100 ;

                   DUP 3 ;

                   GET 15 ;

                   SIZE ;

                   COMPARE ;

                   LE ;

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

                   PUSH nat 0 ;

                   DUP 3 ;

                   GET 15 ;

                   ITER { CDR ; ADD } ;