Better Call Dev

Contract factory
​x
 
{ parameter (or
              (or (or (nat %bid) (nat %cashout))
                  (or (unit %confirm_ownership) (nat %migrate)))
              (or
                (or
                  (or %migration_required_action
                    (or (or (nat %buyout) (nat %claim_fees))
                        (or
                          (pair %create (map %vault_tokens (pair address nat) nat)
                                        (string %name)
                                        (string %description)
                                        (nat %total_supply)
                                        (map %royalties address nat)
                                        (nat %curator_pct)
                                        (option %sell_order (pair (nat %amount)
                                                                 (mutez %price)
                                                                 (map %recipients
                                                                   address
                                                                   nat)
                                                                 (option %valid_from timestamp)
                                                                 (option %valid_until timestamp))))
                          (or %curator_action
                            (or (pair %transfer_curatorship nat address)
                                (pair %update_curator_pct nat nat))
                            (pair %update_royalties nat (map address nat)))))
                    (or (nat %rescue) (pair %vote_reserve nat mutez)))
                  (or %owner_action
                    (or (or (unit %disable_migration) (address %enable_migration))
                        (or (unit %renounce_ownership) (pair %set_curator nat address)))
                    (or
                      (pair %set_settings (option %slice_address address)
                                          (option %orderbook_address address)
                                          (option %maintenance_recipient address)
                                          (option %maintenance_pct nat)
                                          (option %max_curator_pct nat)
                                          (option %bid_increment mutez)
                                          (option %bid_extension int)
                                          (option %auction_length int)
                                          (option %min_reserve_vote_pct nat)
                                          (option %max_tokens nat)
                                          (option %migration_reward_pct nat)
                                          (option %metadata_base_uri string))
                      (address %transfer_ownership))))
                (or (nat %resolve)
                    (list %transfer_hook (pair (address %from_)
                                              (list %txs (pair (address %to_)
                                                              (nat %token_id)
                                                              (nat %amount)))))))) ;
  storage (pair (big_map %metadata string bytes)
                (pair %roles (address %owner) (option %pending_owner address))
                (pair %settings (address %slice_address) (address %orderbook_address)
                                (address %maintenance_recipient)
                                (nat %maintenance_pct)
                                (nat %max_curator_pct)
                                (mutez %bid_increment)
                                (int %bid_extension)
                                (int %auction_length)
                                (nat %min_reserve_vote_pct)
                                (nat %max_tokens)
                                (nat %migration_reward_pct)
                                (string %metadata_base_uri))
                (pair %migration (bool %enabled) (option %address address))
                (big_map %slices nat
                                 (pair (pair %token address nat) (address %vault)
                                       (map %vault_tokens (pair address nat) nat)
                                       (pair %auction (nat %state) (timestamp %end_time)
                                                      (mutez %bid)
                                                      (address %bidder))
                                       (nat %reserve_total)
                                       (nat %reserve_votes)
                                       (mutez %cashout_pool)
                                       (address %curator)
                                       (nat %curator_pct)
                                       (timestamp %curator_last_claimed)
                                       (timestamp %maintenance_last_claimed)
                                       (bool %migrated)))
                (big_map %slice_metadata nat (map string bytes))
                (big_map %votes (pair address nat) mutez)
                (big_map %hooks (pair address nat) nat)
                (nat %next_slice_id)) ;
  code { NIL operation ;
         PUSH nat 0 ;
         PUSH nat 1 ;
         PUSH nat 2 ;
         PUSH nat 1000000000000000000 ;
         LAMBDA
           mutez
           nat
           { PUSH mutez 1 ; SWAP ; EDIV ; IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; CAR } ;
         LAMBDA
           (pair address mutez)
           operation
           { UNPAIR ;
             CONTRACT unit ;
             IF_NONE { PUSH string "INVALID_TEZ_DESTINATION" ; FAILWITH } {} ;
             SWAP ;
             UNIT ;
             TRANSFER_TOKENS } ;
         LAMBDA nat mutez { PUSH mutez 1 ; SWAP ; MUL } ;
         LAMBDA
           string
           bytes
           { PACK ;
             DUP ;
             PUSH nat 6 ;
             DIG 2 ;
             SIZE ;
             SUB ;
             ABS ;
             PUSH nat 6 ;
             SLICE ;
             IF_NONE { PUSH string "SLICE" ; FAILWITH } {} } ;
         LAMBDA
           (pair nat (big_map string bytes) (pair address (option address))
                 (pair address address address nat nat mutez int int nat nat nat string)
                 (pair bool (option address))
                 (big_map nat
                          (pair (pair address nat) address (map (pair address nat) nat)
                                (pair nat timestamp mutez address)
                                nat
                                nat
                                mutez
                                address
                                nat
                                timestamp
                                timestamp
                                bool))
                 (big_map nat (map string bytes))
                 (big_map (pair address nat) mutez)
                 (big_map (pair address nat) nat)
                 nat)
           (pair (pair address nat) address (map (pair address nat) nat)
                 (pair nat timestamp mutez address)
                 nat
                 nat
                 mutez
                 address
                 nat
                 timestamp
                 timestamp
                 bool)
           { UNPAIR ;
             SWAP ;
             GET 9 ;
             SWAP ;
             GET ;
             IF_NONE { PUSH string "SLICE_UNDEFINED" ; FAILWITH } {} } ;
         LAMBDA
           (pair (pair address nat) (big_map string bytes)
                 (pair address (option address))
                 (pair address address address nat nat mutez int int nat nat nat string)
                 (pair bool (option address))
                 (big_map nat
                          (pair (pair address nat) address (map (pair address nat) nat)
                                (pair nat timestamp mutez address)
                                nat
                                nat
                                mutez
                                address
                                nat
                                timestamp
                                timestamp
                                bool))
                 (big_map nat (map string bytes))
                 (big_map (pair address nat) mutez)
                 (big_map (pair address nat) nat)
                 nat)
           mutez
           { UNPAIR ; UNPAIR ; DIG 2 ; GET 13 ; DUG 2 ; PAIR ; GET ; IF_NONE { PUSH mutez 0 } {} } ;
         LAMBDA
           (pair
             (lambda
               (pair nat (big_map string bytes) (pair address (option address))
                     (pair address address address nat nat mutez int int nat nat nat
                           string)
                     (pair bool (option address))
                     (big_map nat
                              (pair (pair address nat) address
                                    (map (pair address nat) nat)
                                    (pair nat timestamp mutez address)
                                    nat
                                    nat
                                    mutez
                                    address
                                    nat
                                    timestamp
                                    timestamp
                                    bool))
                     (big_map nat (map string bytes))
                     (big_map (pair address nat) mutez)
                     (big_map (pair address nat) nat)
                     nat)
               (pair (pair address nat) address (map (pair address nat) nat)
                     (pair nat timestamp mutez address)
                     nat
                     nat
                     mutez
                     address
                     nat
                     timestamp
                     timestamp
                     bool))
             (pair nat (big_map string bytes) (pair address (option address))
                   (pair address address address nat nat mutez int int nat nat nat
                         string)
                   (pair bool (option address))
                   (big_map nat
                            (pair (pair address nat) address
                                  (map (pair address nat) nat)
                                  (pair nat timestamp mutez address)
                                  nat
                                  nat
                                  mutez
                                  address
                                  nat
                                  timestamp
                                  timestamp
                                  bool))
                   (big_map nat (map string bytes))
                   (big_map (pair address nat) mutez)
                   (big_map (pair address nat) nat)
                   nat))
           nat
           { UNPAIR ;
             SWAP ;
             EXEC ;
             DUP ;
             CAR ;
             CAR ;
             SWAP ;
             CAR ;
             CDR ;
             VIEW "total_supply" nat ;
             IF_NONE { PUSH string "option is None" ; FAILWITH } {} } ;
         DUP 3 ;
         APPLY ;
         LAMBDA
           (pair
             (lambda
               (pair nat (big_map string bytes) (pair address (option address))
                     (pair address address address nat nat mutez int int nat nat nat
                           string)
                     (pair bool (option address))
                     (big_map nat
                              (pair (pair address nat) address
                                    (map (pair address nat) nat)
                                    (pair nat timestamp mutez address)
                                    nat
                                    nat
                                    mutez
                                    address
                                    nat
                                    timestamp
                                    timestamp
                                    bool))
                     (big_map nat (map string bytes))
                     (big_map (pair address nat) mutez)
                     (big_map (pair address nat) nat)
                     nat)
               (pair (pair address nat) address (map (pair address nat) nat)
                     (pair nat timestamp mutez address)
                     nat
                     nat
                     mutez
                     address
                     nat
                     timestamp
                     timestamp
                     bool))
             (pair (pair address nat) (big_map string bytes)
                   (pair address (option address))
                   (pair address address address nat nat mutez int int nat nat nat
                         string)
                   (pair bool (option address))
                   (big_map nat
                            (pair (pair address nat) address
                                  (map (pair address nat) nat)
                                  (pair nat timestamp mutez address)
                                  nat
                                  nat
                                  mutez
                                  address
                                  nat
                                  timestamp
                                  timestamp
                                  bool))
                   (big_map nat (map string bytes))
                   (big_map (pair address nat) mutez)
                   (big_map (pair address nat) nat)
                   nat))
           nat
           { UNPAIR ;
             SWAP ;
             UNPAIR ;
             UNPAIR ;
             DUG 2 ;
             PAIR ;
             DIG 2 ;
             SWAP ;
             EXEC ;
             DUP ;
             CAR ;
             CAR ;
             SWAP ;
             CAR ;
             CDR ;
             DIG 2 ;
             PAIR ;
             VIEW "get_balance" nat ;
             IF_NONE { PUSH string "option is None" ; FAILWITH } {} } ;
         DUP 4 ;
         APPLY ;
         LAMBDA
           (pair
             (lambda
               (pair nat (big_map string bytes) (pair address (option address))
                     (pair address address address nat nat mutez int int nat nat nat
                           string)
                     (pair bool (option address))
                     (big_map nat
                              (pair (pair address nat) address
                                    (map (pair address nat) nat)
                                    (pair nat timestamp mutez address)
                                    nat
                                    nat
                                    mutez
                                    address
                                    nat
                                    timestamp
                                    timestamp
                                    bool))
                     (big_map nat (map string bytes))
                     (big_map (pair address nat) mutez)
                     (big_map (pair address nat) nat)
                     nat)
               (pair (pair address nat) address (map (pair address nat) nat)
                     (pair nat timestamp mutez address)
                     nat
                     nat
                     mutez
                     address
                     nat
                     timestamp
                     timestamp
                     bool))
             (pair (pair address nat) nat (big_map string bytes)
                   (pair address (option address))
                   (pair address address address nat nat mutez int int nat nat nat
                         string)
                   (pair bool (option address))
                   (big_map nat
                            (pair (pair address nat) address
                                  (map (pair address nat) nat)
                                  (pair nat timestamp mutez address)
                                  nat
                                  nat
                                  mutez
                                  address
                                  nat
                                  timestamp
                                  timestamp
                                  bool))
                   (big_map nat (map string bytes))
                   (big_map (pair address nat) mutez)
                   (big_map (pair address nat) nat)
                   nat))
           operation
           { UNPAIR ;
             SWAP ;
             UNPAIR ;
             UNPAIR ;
             DIG 2 ;
             UNPAIR ;
             SWAP ;
             DIG 3 ;
             PAIR ;
             DIG 3 ;
             SWAP ;
             EXEC ;
             DUP ;
             CAR ;
             CAR ;
             CONTRACT %mint (list (pair (address %owner) (nat %token_id) (nat %amount))) ;
             IF_NONE { PUSH string "SLICE_FA2_MINT_UNDEFINED" ; FAILWITH } {} ;
             PUSH mutez 0 ;
             NIL (pair address nat nat) ;
             DIG 4 ;
             DIG 4 ;
             CAR ;
             CDR ;
             DIG 5 ;
             PAIR 3 ;
             CONS ;
             TRANSFER_TOKENS } ;
         DUP 5 ;
         APPLY ;
         LAMBDA
           (pair
             (lambda
               (pair nat (big_map string bytes) (pair address (option address))
                     (pair address address address nat nat mutez int int nat nat nat
                           string)
                     (pair bool (option address))
                     (big_map nat
                              (pair (pair address nat) address
                                    (map (pair address nat) nat)
                                    (pair nat timestamp mutez address)
                                    nat
                                    nat
                                    mutez
                                    address
                                    nat
                                    timestamp
                                    timestamp
                                    bool))
                     (big_map nat (map string bytes))
                     (big_map (pair address nat) mutez)
                     (big_map (pair address nat) nat)
                     nat)
               (pair (pair address nat) address (map (pair address nat) nat)
                     (pair nat timestamp mutez address)
                     nat
                     nat
                     mutez
                     address
                     nat
                     timestamp
                     timestamp
                     bool))
             (pair (pair address nat) nat (big_map string bytes)
                   (pair address (option address))
                   (pair address address address nat nat mutez int int nat nat nat
                         string)
                   (pair bool (option address))
                   (big_map nat
                            (pair (pair address nat) address
                                  (map (pair address nat) nat)
                                  (pair nat timestamp mutez address)
                                  nat
                                  nat
                                  mutez
                                  address
                                  nat
                                  timestamp
                                  timestamp
                                  bool))
                   (big_map nat (map string bytes))
                   (big_map (pair address nat) mutez)
                   (big_map (pair address nat) nat)
                   nat))
           operation
           { UNPAIR ;
             SWAP ;
             UNPAIR ;
             UNPAIR ;
             DIG 2 ;
             UNPAIR ;
             SWAP ;
             DIG 3 ;
             PAIR ;
             DIG 3 ;
             SWAP ;
             EXEC ;
             DUP ;
             CAR ;
             CAR ;
             CONTRACT %burn (list (pair (address %owner) (nat %token_id) (nat %amount))) ;
             IF_NONE { PUSH string "SLICE_FA2_BURN_UNDEFINED" ; FAILWITH } {} ;
             PUSH mutez 0 ;
             NIL (pair address nat nat) ;
             DIG 4 ;
             DIG 4 ;
             CAR ;
             CDR ;
             DIG 5 ;
             PAIR 3 ;
             CONS ;
             TRANSFER_TOKENS } ;
         DUP 6 ;
         APPLY ;
         LAMBDA
           (pair
             (pair
               (lambda
                 (pair (pair address nat) nat (big_map string bytes)
                       (pair address (option address))
                       (pair address address address nat nat mutez int int nat nat nat
                             string)
                       (pair bool (option address))
                       (big_map nat
                                (pair (pair address nat) address
                                      (map (pair address nat) nat)
                                      (pair nat timestamp mutez address)
                                      nat
                                      nat
                                      mutez
                                      address
                                      nat
                                      timestamp
                                      timestamp
                                      bool))
                       (big_map nat (map string bytes))
                       (big_map (pair address nat) mutez)
                       (big_map (pair address nat) nat)
                       nat)
                 operation)
               (lambda
                 (pair nat (big_map string bytes) (pair address (option address))
                       (pair address address address nat nat mutez int int nat nat nat
                             string)
                       (pair bool (option address))
                       (big_map nat
                                (pair (pair address nat) address
                                      (map (pair address nat) nat)
                                      (pair nat timestamp mutez address)
                                      nat
                                      nat
                                      mutez
                                      address
                                      nat
                                      timestamp
                                      timestamp
                                      bool))
                       (big_map nat (map string bytes))
                       (big_map (pair address nat) mutez)
                       (big_map (pair address nat) nat)
                       nat)
                 nat)
               nat)
             (pair
               (pair nat (pair address nat) address (map (pair address nat) nat)
                     (pair nat timestamp mutez address)
                     nat
                     nat
                     mutez
                     address
                     nat
                     timestamp
                     timestamp
                     bool)
               (big_map string bytes)
               (pair address (option address))
               (pair address address address nat nat mutez int int nat nat nat string)
               (pair bool (option address))
               (big_map nat
                        (pair (pair address nat) address (map (pair address nat) nat)
                              (pair nat timestamp mutez address)
                              nat
                              nat
                              mutez
                              address
                              nat
                              timestamp
                              timestamp
                              bool))
               (big_map nat (map string bytes))
               (big_map (pair address nat) mutez)
               (big_map (pair address nat) nat)
               nat))
           (pair
             (pair (pair address nat) address (map (pair address nat) nat)
                   (pair nat timestamp mutez address)
                   nat
                   nat
                   mutez
                   address
                   nat
                   timestamp
                   timestamp
                   bool)
             (list operation))
           { UNPAIR ;
             UNPAIR 3 ;
             DIG 3 ;
             UNPAIR ;
             UNPAIR ;
             SWAP ;
             DUP ;
             GET 19 ;
             NOW ;
             SUB ;
             ABS ;
             DUP 7 ;
             SWAP ;
             PUSH nat 31536000 ;
             PUSH nat 10000 ;
             DUP 10 ;
             DUP 8 ;
             DUP 8 ;
             PAIR ;
             DUP 11 ;
             SWAP ;
             EXEC ;
             DUP 7 ;
             GET 17 ;
             MUL ;
             MUL ;
             EDIV ;
             IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
             CAR ;
             EDIV ;
             IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
             CAR ;
             MUL ;
             EDIV ;
             IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
             CAR ;
             DUP 2 ;
             GET 21 ;
             NOW ;
             SUB ;
             ABS ;
             DUP 8 ;
             SWAP ;
             PUSH nat 31536000 ;
             PUSH nat 10000 ;
             DIG 10 ;
             DUP 9 ;
             DUP 9 ;
             PAIR ;
             DIG 11 ;
             SWAP ;
             EXEC ;
             DUP 10 ;
             GET 5 ;
             GET 7 ;
             MUL ;
             MUL ;
             EDIV ;
             IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
             CAR ;
             EDIV ;
             IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
             CAR ;
             MUL ;
             EDIV ;
             IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
             CAR ;
             NIL operation ;
             PUSH nat 0 ;
             DUP 4 ;
             COMPARE ;
             GT ;
             IF
               { DUP 6 ;
                 DIG 3 ;
                 PAIR ;
                 DUP 5 ;
                 DUP 5 ;
                 GET 15 ;
                 PAIR ;
                 PAIR ;
                 DUP 7 ;
                 SWAP ;
                 EXEC ;
                 CONS ;
                 DIG 2 ;
                 NOW ;
                 UPDATE 19 ;
                 DUG 2 }
               { DIG 2 ; DROP } ;
             PUSH nat 0 ;
             DUP 3 ;
             COMPARE ;
             GT ;
             IF
               { DUP 5 ;
                 DIG 2 ;
                 PAIR ;
                 DIG 3 ;
                 DIG 4 ;
                 GET 5 ;
                 GET 5 ;
                 PAIR ;
                 PAIR ;
                 DIG 3 ;
                 SWAP ;
                 EXEC ;
                 CONS ;
                 SWAP ;
                 NOW ;
                 UPDATE 21 ;
                 SWAP }
               { SWAP ; DIG 3 ; DIG 4 ; DIG 5 ; DROP 4 } ;
             SWAP ;
             PAIR } ;
         DUP 12 ;
         DUP 6 ;
         DUP 5 ;
         PAIR 3 ;
         APPLY ;
         DIG 11 ;
         DROP ;
         LAMBDA
           (pair address address)
           operation
           { UNPAIR ;
             CONTRACT %migrate address ;
             IF_NONE { PUSH string "CANNOT_MIGRATE_VAULT" ; FAILWITH } {} ;
             PUSH mutez 0 ;
             DIG 2 ;
             TRANSFER_TOKENS } ;
         LAMBDA
           (pair
             (pair
               (pair (pair address nat) address (map (pair address nat) nat)
                     (pair nat timestamp mutez address)
                     nat
                     nat
                     mutez
                     address
                     nat
                     timestamp
                     timestamp
                     bool)
               address)
             (list operation))
           (list operation)
           { UNPAIR ;
             UNPAIR ;
             DIG 2 ;
             DUP 2 ;
             GET 3 ;
             CONTRACT %withdraw_token (pair
                                        (pair %token (address %address) (nat %tokenId)
                                                     (or %tokenType (unit %fa1)
                                                                    (unit %fa2)))
                                        (address %destination)
                                        (nat %amount)) ;
             IF_NONE { PUSH string "CANNOT_INVOKE_VAULT_WITHDRAWAL" ; FAILWITH } {} ;
             DIG 2 ;
             GET 5 ;
             ITER { UNPAIR ;
                    DIG 3 ;
                    DUP 4 ;
                    PUSH mutez 0 ;
                    DIG 4 ;
                    DUP 7 ;
                    UNIT ;
                    RIGHT unit ;
                    DUP 7 ;
                    CDR ;
                    DIG 7 ;
                    CAR ;
                    PAIR 3 ;
                    PAIR 3 ;
                    TRANSFER_TOKENS ;
                    CONS ;
                    SWAP } ;
             DIG 2 ;
             DROP 2 } ;
         DIG 17 ;
         UNPAIR ;
         IF_LEFT
           { DIG 2 ;
             DIG 4 ;
             DIG 9 ;
             DIG 11 ;
             DIG 12 ;
             DIG 14 ;
             DROP 6 ;
             IF_LEFT
               { DIG 2 ;
                 DIG 4 ;
                 DIG 11 ;
                 DIG 12 ;
                 DROP 4 ;
                 IF_LEFT
                   { DIG 2 ;
                     DIG 3 ;
                     DIG 4 ;
                     DIG 7 ;
                     DROP 4 ;
                     SWAP ;
                     DUP ;
                     DUP 3 ;
                     PAIR ;
                     DIG 3 ;
                     SWAP ;
                     EXEC ;
                     PUSH string "SLICE_AUCTION_NOT_LIVE" ;
                     DIG 5 ;
                     DUP 3 ;
                     GET 7 ;
                     CAR ;
                     COMPARE ;
                     EQ ;
                     IF { DROP } { FAILWITH } ;
                     PUSH string "SLICE_AUCTION_ENDED" ;
                     NOW ;
                     DUP 3 ;
                     GET 7 ;
                     GET 3 ;
                     COMPARE ;
                     GT ;
                     IF { DROP } { FAILWITH } ;
                     PUSH string "SLICE_AUCTION_LOW_BID" ;
                     DUP 3 ;
                     GET 5 ;
                     GET 11 ;
                     DUP 3 ;
                     GET 7 ;
                     GET 5 ;
                     ADD ;
                     AMOUNT ;
                     COMPARE ;
                     GE ;
                     IF { DROP } { FAILWITH } ;
                     NIL operation ;
                     DUP 2 ;
                     GET 7 ;
                     GET 5 ;
                     DUP 3 ;
                     GET 7 ;
                     GET 6 ;
                     PAIR ;
                     DIG 5 ;
                     SWAP ;
                     EXEC ;
                     CONS ;
                     DUP 2 ;
                     DIG 2 ;
                     GET 7 ;
                     SENDER ;
                     UPDATE 6 ;
                     UPDATE 7 ;
                     SWAP ;
                     DUP 2 ;
                     DIG 2 ;
                     GET 7 ;
                     AMOUNT ;
                     UPDATE 5 ;
                     UPDATE 7 ;
                     SWAP ;
                     DUP 3 ;
                     GET 5 ;
                     GET 13 ;
                     NOW ;
                     DUP 4 ;
                     GET 7 ;
                     GET 3 ;
                     SUB ;
                     COMPARE ;
                     LT ;
                     IF
                       { DUP 2 ; DIG 2 ; GET 7 ; DUP 4 ; GET 5 ; GET 13 ; NOW ; ADD ; UPDATE 3 ; UPDATE 7 ; SWAP }
                       {} ;
                     DUP 3 ;
                     DIG 3 ;
                     GET 9 ;
                     DIG 3 ;
                     DIG 4 ;
                     SWAP ;
                     SOME ;
                     SWAP ;
                     UPDATE ;
                     UPDATE 9 }
                   { DIG 8 ;
                     DROP ;
                     SWAP ;
                     DUP ;
                     DUP 3 ;
                     PAIR ;
                     DIG 6 ;
                     SWAP ;
                     EXEC ;
                     PUSH string "SLICE_NO_CASHOUT" ;
                     DIG 8 ;
                     DUP 3 ;
                     GET 7 ;
                     CAR ;
                     COMPARE ;
                     EQ ;
                     IF { DROP } { FAILWITH } ;
                     DUP 2 ;
                     DUP 4 ;
                     SENDER ;
                     PAIR ;
                     PAIR ;
                     DIG 5 ;
                     SWAP ;
                     EXEC ;
                     PUSH nat 0 ;
                     DUP 2 ;
                     COMPARE ;
                     GT ;
                     IF
                       {}
                       { PUSH string "SLICE_CASHOUT_INSUFFICIENT_BALANCE" ; FAILWITH } ;
                     PUSH string "SLICE_CASHOUT_DRAINED" ;
                     PUSH mutez 0 ;
                     DUP 4 ;
                     GET 13 ;
                     COMPARE ;
                     GT ;
                     IF { DROP } { FAILWITH } ;
                     DUP 3 ;
                     DUP 5 ;
                     PAIR ;
                     DIG 6 ;
                     SWAP ;
                     EXEC ;
                     DUP 3 ;
                     GET 13 ;
                     DUP 3 ;
                     MUL ;
                     EDIV ;
                     IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
                     CAR ;
                     DUP 3 ;
                     GET 13 ;
                     DUP 2 ;
                     COMPARE ;
                     GT ;
                     IF { DROP ; DUP 2 ; GET 13 } {} ;
                     NIL operation ;
                     DUP 5 ;
                     DIG 3 ;
                     PAIR ;
                     DUP 6 ;
                     SENDER ;
                     PAIR ;
                     PAIR ;
                     DIG 6 ;
                     SWAP ;
                     EXEC ;
                     CONS ;
                     DUP 2 ;
                     SENDER ;
                     PAIR ;
                     DIG 6 ;
                     SWAP ;
                     EXEC ;
                     CONS ;
                     DUP 3 ;
                     DIG 2 ;
                     DIG 3 ;
                     GET 13 ;
                     SUB_MUTEZ ;
                     IF_NONE { PUSH string "option is None" ; FAILWITH } {} ;
                     UPDATE 13 ;
                     SWAP ;
                     DUP 3 ;
                     DIG 3 ;
                     GET 9 ;
                     DIG 3 ;
                     DIG 4 ;
                     SWAP ;
                     SOME ;
                     SWAP ;
                     UPDATE ;
                     UPDATE 9 } }
               { DIG 3 ;
                 DIG 5 ;
                 DIG 8 ;
                 DIG 9 ;
                 DIG 10 ;
                 DROP 5 ;
                 IF_LEFT
                   { DIG 2 ;
                     DIG 3 ;
                     DIG 4 ;
                     DIG 5 ;
                     DIG 6 ;
                     DROP 6 ;
                     PUSH string "NO_PENDING_OWNER" ;
                     DUP 2 ;
                     GET 3 ;
                     CDR ;
                     IF_NONE { FAILWITH } { SWAP ; DROP } ;
                     PUSH string "INVALID_PENDING_OWNER_ACCESS" ;
                     DUP 2 ;
                     SENDER ;
                     COMPARE ;
                     EQ ;
                     IF { DROP } { FAILWITH } ;
                     DUP 2 ;
                     DIG 2 ;
                     GET 3 ;
                     DIG 2 ;
                     UPDATE 1 ;
                     UPDATE 3 ;
                     DUP ;
                     GET 3 ;
                     NONE address ;
                     UPDATE 2 ;
                     UPDATE 3 }
                   { DIG 7 ;
                     DROP ;
                     SWAP ;
                     PUSH string "SLICE_NO_MIGRATION" ;
                     PUSH bool True ;
                     DUP 3 ;
                     GET 7 ;
                     CAR ;
                     COMPARE ;
                     EQ ;
                     IF { DROP } { FAILWITH } ;
                     DUP ;
                     DUP 3 ;
                     PAIR ;
                     DIG 6 ;
                     SWAP ;
                     EXEC ;
                     PUSH string "SLICE_MIGRATED" ;
                     PUSH bool False ;
                     DUP 3 ;
                     GET 22 ;
                     COMPARE ;
                     EQ ;
                     IF { DROP } { FAILWITH } ;
                     PUSH string "SLICE_NO_MIGRATION" ;
                     DIG 7 ;
                     DUP 3 ;
                     GET 7 ;
                     CAR ;
                     COMPARE ;
                     EQ ;
                     IF { DROP } { FAILWITH } ;
                     NIL operation ;
                     DUP 3 ;
                     GET 7 ;
                     CDR ;
                     IF_NONE { PUSH string "option is None" ; FAILWITH } {} ;
                     DUP ;
                     CONTRACT %migrate_from_v1 (pair (pair %token address nat)
                                                     (address %vault)
                                                     (map %vault_tokens
                                                       (pair address nat)
                                                       nat)
                                                     (address %curator)
                                                     (nat %curator_pct)
                                                     (timestamp %curator_last_claimed)
                                                     (timestamp %maintenance_last_claimed)
                                                     (map %metadata string bytes)) ;
                     IF_NONE { PUSH string "SLICE_MIGRATION_UNDEFINED" ; FAILWITH } {} ;
                     DUP 5 ;
                     GET 11 ;
                     DUP 7 ;
                     GET ;
                     IF_NONE { EMPTY_MAP string bytes } {} ;
                     DUP 5 ;
                     GET 21 ;
                     DUP 6 ;
                     GET 19 ;
                     DUP 7 ;
                     GET 17 ;
                     DUP 8 ;
                     GET 15 ;
                     DUP 9 ;
                     GET 5 ;
                     DUP 10 ;
                     GET 3 ;
                     DUP 11 ;
                     CAR ;
                     PAIR 8 ;
                     DIG 3 ;
                     DIG 2 ;
                     PUSH mutez 0 ;
                     DIG 3 ;
                     TRANSFER_TOKENS ;
                     CONS ;
                     SWAP ;
                     DUP 3 ;
                     GET 3 ;
                     PAIR ;
                     DIG 5 ;
                     SWAP ;
                     EXEC ;
                     CONS ;
                     PUSH nat 0 ;
                     DUP 4 ;
                     GET 5 ;
                     GET 21 ;
                     COMPARE ;
                     GT ;
                     IF
                       { PUSH nat 1 ;
                         PUSH nat 10000 ;
                         DUP 5 ;
                         DUP 7 ;
                         PAIR ;
                         DIG 8 ;
                         SWAP ;
                         EXEC ;
                         DUP 6 ;
                         GET 5 ;
                         GET 21 ;
                         MUL ;
                         EDIV ;
                         IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
                         CAR ;
                         PAIR ;
                         SWAP ;
                         DUP 4 ;
                         DIG 2 ;
                         UNPAIR ;
                         DUP 2 ;
                         DUP 2 ;
                         COMPARE ;
                         GT ;
                         IF { SWAP ; DROP } { DROP } ;
                         PAIR ;
                         DUP 5 ;
                         SENDER ;
                         PAIR ;
                         PAIR ;
                         DIG 5 ;
                         SWAP ;
                         EXEC ;
                         CONS }
                       { DIG 4 ; DIG 5 ; DROP 2 } ;
                     SWAP ;
                     PUSH bool True ;
                     UPDATE 22 ;
                     SWAP ;
                     DUP 3 ;
                     DIG 3 ;
                     GET 9 ;
                     DIG 3 ;
                     DIG 4 ;
                     SWAP ;
                     SOME ;
                     SWAP ;
                     UPDATE ;
                     UPDATE 9 } } ;
             SWAP }
           { IF_LEFT
               { DIG 13 ;
                 DIG 15 ;
                 DROP 2 ;
                 IF_LEFT
                   { SWAP ;
                     PUSH string "SLICE_MIGRATION_REQUIRED" ;
                     PUSH bool False ;
                     DUP 3 ;
                     GET 7 ;
                     CAR ;
                     COMPARE ;
                     EQ ;
                     IF { DROP } { FAILWITH } ;
                     SWAP ;
                     IF_LEFT
                       { DIG 2 ;
                         DIG 3 ;
                         DIG 5 ;
                         DIG 7 ;
                         DIG 9 ;
                         DIG 13 ;
                         DROP 6 ;
                         IF_LEFT
                           { DIG 3 ;
                             DIG 6 ;
                             DIG 10 ;
                             DROP 3 ;
                             IF_LEFT
                               { SWAP ;
                                 DUP ;
                                 DUP 3 ;
                                 PAIR ;
                                 DIG 5 ;
                                 SWAP ;
                                 EXEC ;
                                 PUSH string "SLICE_NO_BUYOUTS" ;
                                 DIG 8 ;
                                 DUP 3 ;
                                 GET 7 ;
                                 CAR ;
                                 COMPARE ;
                                 EQ ;
                                 IF { DROP } { FAILWITH } ;
                                 PUSH string "SLICE_BUYOUT_LOW_BID" ;
                                 DUP 2 ;
                                 PUSH mutez 0 ;
                                 PUSH nat 0 ;
                                 DUP 3 ;
                                 GET 11 ;
                                 COMPARE ;
                                 GT ;
                                 IF
                                   { DROP ;
                                     DUP ;
                                     GET 11 ;
                                     SWAP ;
                                     GET 9 ;
                                     EDIV ;
                                     IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
                                     CAR ;
                                     DIG 7 ;
                                     SWAP ;
                                     EXEC }
                                   { SWAP ; DIG 8 ; DROP 2 } ;
                                 AMOUNT ;
                                 COMPARE ;
                                 GE ;
                                 IF { DROP } { FAILWITH } ;
                                 PUSH string "SLICE_BUYOUT_LOW_VOTES" ;
                                 DUP 3 ;
                                 DUP 5 ;
                                 PAIR ;
                                 DIG 6 ;
                                 SWAP ;
                                 EXEC ;
                                 DUP 4 ;
                                 GET 5 ;
                                 GET 17 ;
                                 MUL ;
                                 PUSH nat 10000 ;
                                 DUP 4 ;
                                 GET 11 ;
                                 MUL ;
                                 COMPARE ;
                                 GE ;
                                 IF { DROP } { FAILWITH } ;
                                 DUP ;
                                 GET 7 ;
                                 DIG 5 ;
                                 UPDATE 1 ;
                                 UPDATE 7 ;
                                 DUP ;
                                 GET 7 ;
                                 SENDER ;
                                 UPDATE 6 ;
                                 UPDATE 7 ;
                                 DUP ;
                                 GET 7 ;
                                 AMOUNT ;
                                 UPDATE 5 ;
                                 UPDATE 7 ;
                                 DUP ;
                                 GET 7 ;
                                 DUP 3 ;
                                 GET 5 ;
                                 GET 15 ;
                                 NOW ;
                                 ADD ;
                                 UPDATE 3 ;
                                 UPDATE 7 ;
                                 DUP 2 ;
                                 SWAP ;
                                 DUP 4 ;
                                 PAIR ;
                                 PAIR ;
                                 DIG 3 ;
                                 SWAP ;
                                 EXEC ;
                                 DUP 2 ;
                                 DIG 2 ;
                                 GET 9 ;
                                 DUP 3 ;
                                 CAR ;
                                 DIG 4 ;
                                 SWAP ;
                                 SOME ;
                                 SWAP ;
                                 UPDATE ;
                                 UPDATE 9 ;
                                 SWAP ;
                                 CDR }
                               { DIG 3 ;
                                 DIG 5 ;
                                 DIG 6 ;
                                 DROP 3 ;
                                 SWAP ;
                                 DUP ;
                                 DUP 3 ;
                                 PAIR ;
                                 DIG 4 ;
                                 SWAP ;
                                 EXEC ;
                                 EMPTY_SET address ;
                                 DUP 3 ;
                                 GET 5 ;
                                 GET 5 ;
                                 PUSH bool True ;
                                 SWAP ;
                                 UPDATE ;
                                 DUP 3 ;
                                 GET 3 ;
                                 CAR ;
                                 PUSH bool True ;
                                 SWAP ;
                                 UPDATE ;
                                 DUP 2 ;
                                 GET 15 ;
                                 PUSH bool True ;
                                 SWAP ;
                                 UPDATE ;
                                 PUSH string "INVALID_ACCESS" ;
                                 SWAP ;
                                 SENDER ;
                                 MEM ;
                                 IF { DROP } { FAILWITH } ;
                                 PUSH string "SLICE_NO_MORE_CLAIMING" ;
                                 DIG 5 ;
                                 DUP 3 ;
                                 GET 7 ;
                                 CAR ;
                                 COMPARE ;
                                 EQ ;
                                 IF { DROP } { FAILWITH } ;
                                 DUP 2 ;
                                 SWAP ;
                                 DUP 4 ;
                                 PAIR ;
                                 PAIR ;
                                 DIG 3 ;
                                 SWAP ;
                                 EXEC ;
                                 DUP 2 ;
                                 DIG 2 ;
                                 GET 9 ;
                                 DUP 3 ;
                                 CAR ;
                                 DIG 4 ;
                                 SWAP ;
                                 SOME ;
                                 SWAP ;
                                 UPDATE ;
                                 UPDATE 9 ;
                                 SWAP ;
                                 CDR } }
                           { DIG 4 ;
                             DIG 7 ;
                             DIG 8 ;
                             DROP 3 ;
                             IF_LEFT
                               { DIG 2 ;
                                 DIG 4 ;
                                 DIG 7 ;
                                 DROP 3 ;
                                 SWAP ;
                                 PUSH string "MAX_TOKENS_EXCEEDED" ;
                                 DUP 2 ;
                                 GET 5 ;
                                 GET 19 ;
                                 DUP 4 ;
                                 CAR ;
                                 SIZE ;
                                 COMPARE ;
                                 LE ;
                                 IF { DROP } { FAILWITH } ;
                                 PUSH string "MAX_CURATOR_PCT_EXCEEDED" ;
                                 DUP 2 ;
                                 GET 5 ;
                                 GET 9 ;
                                 DUP 4 ;
                                 GET 11 ;
                                 COMPARE ;
                                 LE ;
                                 IF { DROP } { FAILWITH } ;
                                 PUSH nat 1 ;
                                 DUP 3 ;
                                 GET 7 ;
                                 COMPARE ;
                                 GT ;
                                 IF
                                   {}
                                   { PUSH string "INVALID_TOTAL_SUPPLY" ; FAILWITH } ;
                                 PUSH nat 0 ;
                                 DUP 3 ;
                                 GET 3 ;
                                 SIZE ;
                                 COMPARE ;
                                 GT ;
                                 IF
                                   {}
                                   { PUSH string "MISSING_REQUIRED_NAME" ; FAILWITH } ;
                                 PUSH nat 0 ;
                                 DUP 3 ;
                                 GET 5 ;
                                 SIZE ;
                                 COMPARE ;
                                 GT ;
                                 IF
                                   {}
                                   { PUSH string "MISSING_REQUIRED_DESCRIPTION" ;
                                     FAILWITH } ;
                                 DUP ;
                                 GET 16 ;
                                 DUP 2 ;
                                 PUSH nat 1 ;
                                 DIG 3 ;
                                 GET 16 ;
                                 ADD ;
                                 UPDATE 16 ;
                                 SWAP ;
                                 DUP 2 ;
                                 GET 5 ;
                                 CAR ;
                                 UNIT ;
                                 VIEW "next_token_id" nat ;
                                 IF_NONE
                                   { PUSH string "option is None" ; FAILWITH }
                                   {} ;
                                 EMPTY_MAP string bytes ;
                                 PUSH bytes 0x31 ;
                                 SOME ;
                                 PUSH string "version" ;
                                 UPDATE ;
                                 DUP 5 ;
                                 GET 3 ;
                                 DUP 8 ;
                                 SWAP ;
                                 EXEC ;
                                 SOME ;
                                 PUSH string "name" ;
                                 UPDATE ;
                                 DUP 5 ;
                                 GET 5 ;
                                 DUP 8 ;
                                 SWAP ;
                                 EXEC ;
                                 SOME ;
                                 PUSH string "description" ;
                                 UPDATE ;
                                 EMPTY_MAP string bytes ;
                                 DUP 3 ;
                                 { PUSH string "" ;
                                   PAIR ;
                                   LEFT (pair string nat) ;
                                   LOOP_LEFT { DUP ;
                                               CDR ;
                                               PUSH nat 0 ;
                                               SWAP ;
                                               DUP ;
                                               DUG 2 ;
                                               COMPARE ;
                                               GT ;
                                               IF
                                                 { SWAP ;
                                                   CAR ;
                                                   PUSH nat 10 ;
                                                   DUP 3 ;
                                                   EDIV ;
                                                   IF_NONE
                                                     { PUSH string "MOD by 0" ; FAILWITH }
                                                     {} ;
                                                   CDR ;
                                                   EMPTY_MAP nat string ;
                                                   PUSH string "9" ;
                                                   SOME ;
                                                   PUSH nat 9 ;
                                                   UPDATE ;
                                                   PUSH string "8" ;
                                                   SOME ;
                                                   PUSH nat 8 ;
                                                   UPDATE ;
                                                   PUSH string "7" ;
                                                   SOME ;
                                                   PUSH nat 7 ;
                                                   UPDATE ;
                                                   PUSH string "6" ;
                                                   SOME ;
                                                   PUSH nat 6 ;
                                                   UPDATE ;
                                                   PUSH string "5" ;
                                                   SOME ;
                                                   PUSH nat 5 ;
                                                   UPDATE ;
                                                   PUSH string "4" ;
                                                   SOME ;
                                                   PUSH nat 4 ;
                                                   UPDATE ;
                                                   PUSH string "3" ;
                                                   SOME ;
                                                   PUSH nat 3 ;
                                                   UPDATE ;
                                                   PUSH string "2" ;
                                                   SOME ;
                                                   PUSH nat 2 ;
                                                   UPDATE ;
                                                   PUSH string "1" ;
                                                   SOME ;
                                                   PUSH nat 1 ;
                                                   UPDATE ;
                                                   PUSH string "0" ;
                                                   SOME ;
                                                   PUSH nat 0 ;
                                                   UPDATE ;
                                                   SWAP ;
                                                   GET ;
                                                   IF_NONE
                                                     { PUSH string "INVALID_NAT" ;
                                                       FAILWITH }
                                                     {} ;
                                                   CONCAT ;
                                                   PUSH nat 10 ;
                                                   DIG 2 ;
                                                   EDIV ;
                                                   IF_NONE
                                                     { PUSH string "DIV by 0" ; FAILWITH }
                                                     {} ;
                                                   CAR ;
                                                   SWAP ;
                                                   PAIR ;
                                                   LEFT (pair string nat) }
                                                 { DROP ; RIGHT (pair string nat) } } ;
                                   CAR ;
                                   PUSH string "" ;
                                   SWAP ;
                                   DUP ;
                                   DUG 2 ;
                                   COMPARE ;
                                   EQ ;
                                   IF { DROP ; PUSH string "0" } {} } ;
                                 DUP 6 ;
                                 GET 5 ;
                                 GET 22 ;
                                 CONCAT ;
                                 DIG 8 ;
                                 SWAP ;
                                 EXEC ;
                                 SOME ;
                                 PUSH string "" ;
                                 UPDATE ;
                                 DUP 3 ;
                                 PAIR ;
                                 DUP 6 ;
                                 GET 9 ;
                                 DUP 6 ;
                                 GET 5 ;
                                 GET 7 ;
                                 DUP 7 ;
                                 GET 5 ;
                                 GET 5 ;
                                 SWAP ;
                                 SOME ;
                                 SWAP ;
                                 UPDATE ;
                                 PUSH nat 4 ;
                                 PAIR ;
                                 NIL operation ;
                                 SELF_ADDRESS ;
                                 PUSH mutez 0 ;
                                 NONE key_hash ;
                                 CREATE_CONTRACT { parameter (or
                                                               (or (unit %default)
                                                                   (address %migrate))
                                                               (or
                                                                 (pair %withdraw_tez
                                                                   (address %destination)
                                                                   (mutez %amount))
                                                                 (pair %withdraw_token
                                                                   (pair %token
                                                                     (address %address)
                                                                     (nat %tokenId)
                                                                     (or %tokenType
                                                                       (unit %fa1)
                                                                       (unit %fa2)))
                                                                   (address %destination)
                                                                   (nat %amount)))) ;
                                                   storage address ;
                                                   code { UNPAIR ;
                                                          PUSH string "INVALID_ACCESS" ;
                                                          DUP 3 ;
                                                          SENDER ;
                                                          COMPARE ;
                                                          EQ ;
                                                          IF { DROP } { FAILWITH } ;
                                                          IF_LEFT
                                                            { IF_LEFT
                                                                { DROP }
                                                                { SWAP ; DROP } ;
                                                              NIL operation }
                                                            { IF_LEFT
                                                                { SWAP ;
                                                                  NIL operation ;
                                                                  DUP 3 ;
                                                                  CDR ;
                                                                  DIG 3 ;
                                                                  CAR ;
                                                                  PAIR ;
                                                                  { UNPAIR ;
                                                                    CONTRACT unit ;
                                                                    IF_NONE
                                                                      { PUSH string "INVALID_TEZ_DESTINATION" ;
                                                                        FAILWITH }
                                                                      {} ;
                                                                    SWAP ;
                                                                    UNIT ;
                                                                    TRANSFER_TOKENS } }
                                                                { SWAP ;
                                                                  NIL operation ;
                                                                  DUP 3 ;
                                                                  GET 4 ;
                                                                  DUP 4 ;
                                                                  CAR ;
                                                                  PAIR ;
                                                                  DIG 3 ;
                                                                  GET 3 ;
                                                                  SELF_ADDRESS ;
                                                                  PAIR ;
                                                                  PAIR ;
                                                                  { UNPAIR ;
                                                                    UNPAIR ;
                                                                    DIG 2 ;
                                                                    UNPAIR ;
                                                                    DUP ;
                                                                    GET 4 ;
                                                                    IF_LEFT
                                                                      { DROP ;
                                                                        CAR ;
                                                                        CONTRACT %transfer (pair
                                                                                             (address %from)
                                                                                             (address %to)
                                                                                             (nat %value)) ;
                                                                        IF_NONE
                                                                          { PUSH string "CANNOT_INVOKE_FA1_TRANSFER" ;
                                                                            FAILWITH }
                                                                          {} ;
                                                                        PUSH mutez 0 ;
                                                                        DIG 2 ;
                                                                        DIG 4 ;
                                                                        DIG 4 ;
                                                                        PAIR 3 ;
                                                                        TRANSFER_TOKENS }
                                                                      { DROP ;
                                                                        DUP ;
                                                                        CAR ;
                                                                        CONTRACT %transfer (list (pair
                                                                                                  (address %from_)
                                                                                                  (list %txs (pair
                                                                                                              (address %to_)
                                                                                                              (nat %token_id)
                                                                                                              (nat %amount))))) ;
                                                                        IF_NONE
                                                                          { PUSH string "CANNOT_INVOKE_FA2_TRANSFER" ;
                                                                            FAILWITH }
                                                                          {} ;
                                                                        PUSH mutez 0 ;
                                                                        NIL (pair
                                                                              address
                                                                              (list (pair
                                                                                     address
                                                                                     nat
                                                                                     nat))) ;
                                                                        NIL (pair
                                                                              address
                                                                              nat
                                                                              nat) ;
                                                                        DIG 5 ;
                                                                        DIG 5 ;
                                                                        GET 3 ;
                                                                        DIG 7 ;
                                                                        PAIR 3 ;
                                                                        CONS ;
                                                                        DIG 4 ;
                                                                        PAIR ;
                                                                        CONS ;
                                                                        TRANSFER_TOKENS } } } ;
                                                              CONS } ;
                                                          PAIR } } ;
                                 PAIR ;
                                 SWAP ;
                                 DUP 2 ;
                                 CAR ;
                                 CONS ;
                                 SWAP ;
                                 PUSH bool False ;
                                 NOW ;
                                 NOW ;
                                 DUP 12 ;
                                 GET 11 ;
                                 SENDER ;
                                 PUSH mutez 0 ;
                                 PUSH nat 0 ;
                                 PUSH nat 0 ;
                                 SELF_ADDRESS ;
                                 PUSH mutez 0 ;
                                 NOW ;
                                 DIG 21 ;
                                 PAIR 4 ;
                                 DUP 18 ;
                                 CAR ;
                                 DIG 10 ;
                                 CDR ;
                                 DUP 16 ;
                                 DUP 19 ;
                                 GET 5 ;
                                 CAR ;
                                 PAIR ;
                                 PAIR 12 ;
                                 DUP 8 ;
                                 DIG 8 ;
                                 GET 9 ;
                                 DUP 3 ;
                                 DUP 10 ;
                                 SWAP ;
                                 SOME ;
                                 SWAP ;
                                 UPDATE ;
                                 UPDATE 9 ;
                                 DUG 7 ;
                                 DUP 8 ;
                                 DIG 8 ;
                                 GET 11 ;
                                 DIG 6 ;
                                 DUP 9 ;
                                 SWAP ;
                                 SOME ;
                                 SWAP ;
                                 UPDATE ;
                                 UPDATE 11 ;
                                 DUG 6 ;
                                 DUP 7 ;
                                 DUP 8 ;
                                 GET 15 ;
                                 DUP 8 ;
                                 DUP 8 ;
                                 DIG 10 ;
                                 GET 5 ;
                                 CAR ;
                                 PAIR ;
                                 SWAP ;
                                 SOME ;
                                 SWAP ;
                                 UPDATE ;
                                 UPDATE 15 ;
                                 DUG 6 ;
                                 DUP ;
                                 GET 5 ;
                                 ITER { UNPAIR ;
                                        DIG 3 ;
                                        DIG 2 ;
                                        UNIT ;
                                        RIGHT unit ;
                                        DUP 4 ;
                                        CDR ;
                                        DIG 4 ;
                                        CAR ;
                                        PAIR 3 ;
                                        PAIR ;
                                        DUP 3 ;
                                        GET 3 ;
                                        SENDER ;
                                        DIG 2 ;
                                        UNPAIR ;
                                        DUP ;
                                        GET 4 ;
                                        IF_LEFT
                                          { DROP ;
                                            CAR ;
                                            CONTRACT %transfer (pair (address %from)
                                                                     (address %to)
                                                                     (nat %value)) ;
                                            IF_NONE
                                              { PUSH string "CANNOT_INVOKE_FA1_TRANSFER" ;
                                                FAILWITH }
                                              {} ;
                                            PUSH mutez 0 ;
                                            DIG 2 ;
                                            DIG 4 ;
                                            DIG 4 ;
                                            PAIR 3 ;
                                            TRANSFER_TOKENS }
                                          { DROP ;
                                            DUP ;
                                            CAR ;
                                            CONTRACT %transfer (list (pair
                                                                      (address %from_)
                                                                      (list %txs (pair
                                                                                  (address %to_)
                                                                                  (nat %token_id)
                                                                                  (nat %amount))))) ;
                                            IF_NONE
                                              { PUSH string "CANNOT_INVOKE_FA2_TRANSFER" ;
                                                FAILWITH }
                                              {} ;
                                            PUSH mutez 0 ;
                                            NIL (pair address
                                                      (list (pair address nat nat))) ;
                                            NIL (pair address nat nat) ;
                                            DIG 5 ;
                                            DIG 5 ;
                                            GET 3 ;
                                            DIG 7 ;
                                            PAIR 3 ;
                                            CONS ;
                                            DIG 4 ;
                                            PAIR ;
                                            CONS ;
                                            TRANSFER_TOKENS } ;
                                        CONS ;
                                        SWAP } ;
                                 DROP ;
                                 DUP 7 ;
                                 GET 12 ;
                                 IF_NONE
                                   { DIG 3 ;
                                     DROP ;
                                     DUP 5 ;
                                     DIG 6 ;
                                     GET 7 ;
                                     PAIR ;
                                     DIG 4 ;
                                     SENDER ;
                                     PAIR ;
                                     PAIR ;
                                     DIG 5 ;
                                     SWAP ;
                                     EXEC ;
                                     CONS }
                                   { DUP ;
                                     CAR ;
                                     DUP 9 ;
                                     GET 7 ;
                                     COMPARE ;
                                     GE ;
                                     IF
                                       {}
                                       { PUSH string "INVALID_SELL_ORDER_AMOUNT" ;
                                         FAILWITH } ;
                                     DUP 7 ;
                                     GET 5 ;
                                     CAR ;
                                     CONTRACT %update_operators (list (or
                                                                       (pair %add_operator
                                                                         (address %owner)
                                                                         (address %operator)
                                                                         (nat %token_id))
                                                                       (pair %remove_operator
                                                                         (address %owner)
                                                                         (address %operator)
                                                                         (nat %token_id)))) ;
                                     IF_NONE
                                       { PUSH string "CANNOT_INVOKE_FA2_UPDATE_OPERATORS" ;
                                         FAILWITH }
                                       {} ;
                                     DUP 8 ;
                                     GET 5 ;
                                     GET 3 ;
                                     CONTRACT %make_proxy_order (pair address
                                                                      (or %order_type
                                                                        (unit %buy)
                                                                        (unit %sell))
                                                                      (pair %token
                                                                        (address %address)
                                                                        (nat %tokenId)
                                                                        (or %tokenType
                                                                          (unit %fa1)
                                                                          (unit %fa2)))
                                                                      (nat %amount)
                                                                      (mutez %price)
                                                                      (map %recipients
                                                                        address
                                                                        nat)
                                                                      (option %valid_from timestamp)
                                                                      (option %valid_until timestamp)) ;
                                     IF_NONE
                                       { PUSH string "CANNOT_INVOKE_ORDERBOOK_MAKE_PROXY_ORDER" ;
                                         FAILWITH }
                                       {} ;
                                     DUP 7 ;
                                     DUP 10 ;
                                     GET 5 ;
                                     GET 3 ;
                                     SELF_ADDRESS ;
                                     PAIR 3 ;
                                     DUP 4 ;
                                     GET 8 ;
                                     DUP 5 ;
                                     GET 7 ;
                                     DUP 6 ;
                                     GET 5 ;
                                     DUP 7 ;
                                     GET 3 ;
                                     DUP 8 ;
                                     CAR ;
                                     UNIT ;
                                     RIGHT unit ;
                                     DIG 13 ;
                                     DUP 16 ;
                                     GET 5 ;
                                     CAR ;
                                     PAIR 3 ;
                                     UNIT ;
                                     RIGHT unit ;
                                     PAIR 7 ;
                                     DIG 5 ;
                                     DUP 5 ;
                                     PUSH mutez 0 ;
                                     NIL (or (pair address address nat)
                                             (pair address address nat)) ;
                                     DUP 6 ;
                                     RIGHT (pair address address nat) ;
                                     CONS ;
                                     TRANSFER_TOKENS ;
                                     CONS ;
                                     DIG 3 ;
                                     PUSH mutez 0 ;
                                     DIG 3 ;
                                     SENDER ;
                                     PAIR ;
                                     TRANSFER_TOKENS ;
                                     CONS ;
                                     DIG 2 ;
                                     PUSH mutez 0 ;
                                     NIL (or (pair address address nat)
                                             (pair address address nat)) ;
                                     DIG 4 ;
                                     LEFT (pair address address nat) ;
                                     CONS ;
                                     TRANSFER_TOKENS ;
                                     CONS ;
                                     DUP 6 ;
                                     DUP 3 ;
                                     CAR ;
                                     PAIR ;
                                     DUP 6 ;
                                     SELF_ADDRESS ;
                                     PAIR ;
                                     PAIR ;
                                     DUP 9 ;
                                     SWAP ;
                                     EXEC ;
                                     CONS ;
                                     SWAP ;
                                     CAR ;
                                     DIG 6 ;
                                     GET 7 ;
                                     SUB ;
                                     ABS ;
                                     PUSH nat 0 ;
                                     DUP 2 ;
                                     COMPARE ;
                                     GT ;
                                     IF
                                       { SWAP ;
                                         DUP 6 ;
                                         DIG 2 ;
                                         PAIR ;
                                         DIG 4 ;
                                         SENDER ;
                                         PAIR ;
                                         PAIR ;
                                         DIG 5 ;
                                         SWAP ;
                                         EXEC ;
                                         CONS }
                                       { DIG 4 ; DIG 6 ; DROP 3 } } ;
                                 SWAP ;
                                 DIG 2 ;
                                 PAIR ;
                                 DUP 3 ;
                                 GET 5 ;
                                 CAR ;
                                 CONTRACT %create (pair
                                                    (pair %token_metadata
                                                      (nat %token_id)
                                                      (map %token_info string bytes))
                                                    (pair %royalties (nat %decimals)
                                                                     (map %shares
                                                                       address
                                                                       nat))) ;
                                 IF_NONE
                                   { PUSH string "SLICE_FA2_CREATE_UNDEFINED" ; FAILWITH }
                                   {} ;
                                 PUSH mutez 0 ;
                                 DIG 2 ;
                                 TRANSFER_TOKENS ;
                                 CONS }
                               { DIG 3 ;
                                 DIG 5 ;
                                 DROP 2 ;
                                 IF_LEFT
                                   { IF_LEFT
                                       { DIG 2 ;
                                         DIG 4 ;
                                         DROP 2 ;
                                         UNPAIR ;
                                         DIG 2 ;
                                         DUP ;
                                         DUP 3 ;
                                         PAIR ;
                                         DIG 4 ;
                                         SWAP ;
                                         EXEC ;
                                         PUSH string "INVALID_ACCESS" ;
                                         DUP 2 ;
                                         GET 15 ;
                                         SENDER ;
                                         COMPARE ;
                                         EQ ;
                                         IF { DROP } { FAILWITH } ;
                                         DIG 3 ;
                                         UPDATE 15 ;
                                         DUP 2 ;
                                         DIG 2 ;
                                         GET 9 ;
                                         DIG 2 ;
                                         DIG 3 ;
                                         SWAP ;
                                         SOME ;
                                         SWAP ;
                                         UPDATE ;
                                         UPDATE 9 ;
                                         SWAP }
                                       { DIG 5 ;
                                         DROP ;
                                         UNPAIR ;
                                         DIG 2 ;
                                         DUP ;
                                         DUP 3 ;
                                         PAIR ;
                                         DIG 5 ;
                                         SWAP ;
                                         EXEC ;
                                         PUSH string "INVALID_ACCESS" ;
                                         DUP 2 ;
                                         GET 15 ;
                                         SENDER ;
                                         COMPARE ;
                                         EQ ;
                                         IF { DROP } { FAILWITH } ;
                                         PUSH string "SLICE_NO_MORE_CLAIMING" ;
                                         DIG 6 ;
                                         DUP 3 ;
                                         GET 7 ;
                                         CAR ;
                                         COMPARE ;
                                         EQ ;
                                         IF { DROP } { FAILWITH } ;
                                         PUSH string "MAX_CURATOR_PCT_EXCEEDED" ;
                                         DUP 3 ;
                                         GET 5 ;
                                         GET 9 ;
                                         DUP 6 ;
                                         COMPARE ;
                                         LE ;
                                         IF { DROP } { FAILWITH } ;
                                         DUP 2 ;
                                         SWAP ;
                                         DUP 4 ;
                                         PAIR ;
                                         PAIR ;
                                         DIG 4 ;
                                         SWAP ;
                                         EXEC ;
                                         DUP ;
                                         CAR ;
                                         DIG 4 ;
                                         UPDATE 17 ;
                                         SWAP ;
                                         DUP 3 ;
                                         DIG 3 ;
                                         GET 9 ;
                                         DIG 3 ;
                                         DIG 4 ;
                                         SWAP ;
                                         SOME ;
                                         SWAP ;
                                         UPDATE ;
                                         UPDATE 9 ;
                                         SWAP ;
                                         CDR } }
                                   { DIG 2 ;
                                     DIG 5 ;
                                     DROP 2 ;
                                     UNPAIR ;
                                     SWAP ;
                                     DUP 3 ;
                                     DUP 3 ;
                                     PAIR ;
                                     DUP 5 ;
                                     SWAP ;
                                     EXEC ;
                                     PUSH string "INVALID_ACCESS" ;
                                     DUP 2 ;
                                     GET 15 ;
                                     SENDER ;
                                     COMPARE ;
                                     EQ ;
                                     IF { DROP } { FAILWITH } ;
                                     DIG 5 ;
                                     SWAP ;
                                     GET 7 ;
                                     CAR ;
                                     COMPARE ;
                                     EQ ;
                                     IF
                                       {}
                                       { PUSH string "SLICE_CANNOT_UPDATE_ROYALTIES" ;
                                         FAILWITH } ;
                                     DUP 3 ;
                                     GET 5 ;
                                     GET 7 ;
                                     DUP 4 ;
                                     GET 5 ;
                                     GET 5 ;
                                     SWAP ;
                                     SOME ;
                                     SWAP ;
                                     UPDATE ;
                                     PUSH nat 4 ;
                                     PAIR ;
                                     DUP 3 ;
                                     NIL operation ;
                                     DIG 4 ;
                                     DIG 4 ;
                                     PAIR ;
                                     DIG 4 ;
                                     SWAP ;
                                     EXEC ;
                                     DUP ;
                                     CAR ;
                                     CAR ;
                                     CONTRACT %update_royalties (map nat
                                                                     (pair
                                                                       (nat %decimals)
                                                                       (map %shares
                                                                         address
                                                                         nat))) ;
                                     IF_NONE
                                       { PUSH string "SLICE_FA2_UPDATE_ROYALTIES_UNDEFINED" ;
                                         FAILWITH }
                                       {} ;
                                     PUSH mutez 0 ;
                                     EMPTY_MAP nat (pair nat (map address nat)) ;
                                     DIG 6 ;
                                     DIG 4 ;
                                     CAR ;
                                     CDR ;
                                     SWAP ;
                                     SOME ;
                                     SWAP ;
                                     UPDATE ;
                                     TRANSFER_TOKENS ;
                                     CONS } } } }
                       { DIG 4 ;
                         DIG 6 ;
                         DIG 11 ;
                         DIG 12 ;
                         DIG 14 ;
                         DROP 5 ;
                         IF_LEFT
                           { DIG 5 ;
                             DIG 7 ;
                             DIG 9 ;
                             DIG 11 ;
                             DROP 4 ;
                             SWAP ;
                             DUP ;
                             DUP 3 ;
                             PAIR ;
                             DIG 7 ;
                             SWAP ;
                             EXEC ;
                             PUSH string "SLICE_NO_RESCUING" ;
                             DIG 8 ;
                             DUP 3 ;
                             GET 7 ;
                             CAR ;
                             COMPARE ;
                             EQ ;
                             IF { DROP } { FAILWITH } ;
                             NIL operation ;
                             DUP 3 ;
                             DUP 4 ;
                             DUP 6 ;
                             PAIR ;
                             DIG 9 ;
                             SWAP ;
                             EXEC ;
                             PAIR ;
                             DUP 5 ;
                             SENDER ;
                             PAIR ;
                             PAIR ;
                             DIG 7 ;
                             SWAP ;
                             EXEC ;
                             CONS ;
                             SENDER ;
                             DUP 3 ;
                             GET 3 ;
                             PAIR ;
                             DIG 6 ;
                             SWAP ;
                             EXEC ;
                             CONS ;
                             SENDER ;
                             DUP 3 ;
                             PAIR ;
                             PAIR ;
                             DIG 4 ;
                             SWAP ;
                             EXEC ;
                             DUP 2 ;
                             DIG 2 ;
                             GET 7 ;
                             SENDER ;
                             UPDATE 6 ;
                             UPDATE 7 ;
                             SWAP ;
                             DUP 2 ;
                             DIG 2 ;
                             GET 7 ;
                             PUSH nat 3 ;
                             UPDATE 1 ;
                             UPDATE 7 ;
                             SWAP ;
                             DUP 3 ;
                             DIG 3 ;
                             GET 9 ;
                             DIG 3 ;
                             DIG 4 ;
                             SWAP ;
                             SOME ;
                             SWAP ;
                             UPDATE ;
                             UPDATE 9 }
                           { DIG 2 ;
                             DIG 3 ;
                             DIG 4 ;
                             DIG 6 ;
                             DROP 4 ;
                             UNPAIR ;
                             DIG 2 ;
                             DUP ;
                             DUP 3 ;
                             PAIR ;
                             DIG 6 ;
                             SWAP ;
                             EXEC ;
                             PUSH string "SLICE_NO_VOTING" ;
                             DIG 8 ;
                             DUP 3 ;
                             GET 7 ;
                             CAR ;
                             COMPARE ;
                             EQ ;
                             IF { DROP } { FAILWITH } ;
                             DUP 2 ;
                             DUP 4 ;
                             SENDER ;
                             PAIR ;
                             PAIR ;
                             DIG 5 ;
                             SWAP ;
                             EXEC ;
                             PUSH nat 0 ;
                             DUP 2 ;
                             COMPARE ;
                             GT ;
                             IF {} { PUSH string "SLICE_NO_VOTING_POWER" ; FAILWITH } ;
                             DUP 3 ;
                             DUP 5 ;
                             SENDER ;
                             PAIR ;
                             PAIR ;
                             DIG 6 ;
                             SWAP ;
                             EXEC ;
                             DUP ;
                             DUP 7 ;
                             COMPARE ;
                             NEQ ;
                             IF {} { PUSH string "SLICE_VOTE_UNCHANGED" ; FAILWITH } ;
                             DUP 3 ;
                             DUP 2 ;
                             DUP 9 ;
                             SWAP ;
                             EXEC ;
                             DUP 4 ;
                             MUL ;
                             DUP 8 ;
                             DIG 9 ;
                             SWAP ;
                             EXEC ;
                             DUP 5 ;
                             MUL ;
                             DIG 5 ;
                             GET 9 ;
                             ADD ;
                             SUB ;
                             ABS ;
                             UPDATE 9 ;
                             DUG 2 ;
                             PUSH mutez 0 ;
                             SWAP ;
                             COMPARE ;
                             EQ ;
                             IF
                               { DUP 2 ; DUP 2 ; DIG 3 ; GET 11 ; ADD ; UPDATE 11 ; SWAP }
                               {} ;
                             PUSH mutez 0 ;
                             DUP 6 ;
                             COMPARE ;
                             EQ ;
                             IF
                               { DUP 2 ; SWAP ; DIG 2 ; GET 11 ; SUB ; ABS ; UPDATE 11 }
                               { DROP } ;
                             DUP 2 ;
                             DIG 2 ;
                             GET 9 ;
                             DIG 2 ;
                             DUP 4 ;
                             SWAP ;
                             SOME ;
                             SWAP ;
                             UPDATE ;
                             UPDATE 9 ;
                             DUP ;
                             GET 13 ;
                             DIG 3 ;
                             DIG 3 ;
                             SENDER ;
                             PAIR ;
                             SWAP ;
                             SOME ;
                             SWAP ;
                             UPDATE ;
                             UPDATE 13 } ;
                         SWAP } }
                   { DIG 2 ;
                     DIG 3 ;
                     DIG 4 ;
                     DIG 5 ;
                     DIG 6 ;
                     DIG 7 ;
                     DIG 8 ;
                     DIG 9 ;
                     DIG 11 ;
                     DIG 12 ;
                     DIG 13 ;
                     DIG 14 ;
                     DIG 15 ;
                     DROP 13 ;
                     SWAP ;
                     PUSH string "INVALID_OWNER_ACCESS" ;
                     DUP 2 ;
                     SENDER ;
                     SWAP ;
                     GET 3 ;
                     CAR ;
                     SWAP ;
                     COMPARE ;
                     EQ ;
                     IF { DROP } { FAILWITH } ;
                     SWAP ;
                     IF_LEFT
                       { IF_LEFT
                           { DIG 2 ;
                             DROP ;
                             IF_LEFT
                               { DROP ;
                                 DUP ;
                                 GET 7 ;
                                 PUSH bool False ;
                                 UPDATE 1 ;
                                 UPDATE 7 ;
                                 DUP ;
                                 GET 7 ;
                                 NONE address ;
                                 UPDATE 2 ;
                                 UPDATE 7 }
                               { SWAP ;
                                 DUP ;
                                 GET 7 ;
                                 PUSH bool True ;
                                 UPDATE 1 ;
                                 UPDATE 7 ;
                                 DUP ;
                                 GET 7 ;
                                 DIG 2 ;
                                 SOME ;
                                 UPDATE 2 ;
                                 UPDATE 7 } }
                           { IF_LEFT
                               { DIG 2 ;
                                 DROP 2 ;
                                 DUP ;
                                 GET 3 ;
                                 PUSH address "tz1Ke2h7sDdakHJQh8WX4Z372du1KChsksyU" ;
                                 UPDATE 1 ;
                                 UPDATE 3 }
                               { UNPAIR ;
                                 DIG 2 ;
                                 DUP ;
                                 DUP 3 ;
                                 PAIR ;
                                 DIG 4 ;
                                 SWAP ;
                                 EXEC ;
                                 DIG 3 ;
                                 UPDATE 15 ;
                                 DUP 2 ;
                                 DIG 2 ;
                                 GET 9 ;
                                 DIG 2 ;
                                 DIG 3 ;
                                 SWAP ;
                                 SOME ;
                                 SWAP ;
                                 UPDATE ;
                                 UPDATE 9 } } }
                       { DIG 2 ;
                         DROP ;
                         IF_LEFT
                           { SWAP ;
                             DUP 2 ;
                             CAR ;
                             IF_NONE
                               {}
                               { DUP 2 ; DIG 2 ; GET 5 ; DIG 2 ; UPDATE 1 ; UPDATE 5 } ;
                             DUP 2 ;
                             GET 3 ;
                             IF_NONE
                               {}
                               { DUP 2 ; DIG 2 ; GET 5 ; DIG 2 ; UPDATE 3 ; UPDATE 5 } ;
                             DUP 2 ;
                             GET 5 ;
                             IF_NONE
                               {}
                               { DUP 2 ; DIG 2 ; GET 5 ; DIG 2 ; UPDATE 5 ; UPDATE 5 } ;
                             DUP 2 ;
                             GET 7 ;
                             IF_NONE
                               {}
                               { DUP 2 ; DIG 2 ; GET 5 ; DIG 2 ; UPDATE 7 ; UPDATE 5 } ;
                             DUP 2 ;
                             GET 9 ;
                             IF_NONE
                               {}
                               { DUP 2 ; DIG 2 ; GET 5 ; DIG 2 ; UPDATE 9 ; UPDATE 5 } ;
                             DUP 2 ;
                             GET 11 ;
                             IF_NONE
                               {}
                               { DUP 2 ; DIG 2 ; GET 5 ; DIG 2 ; UPDATE 11 ; UPDATE 5 } ;
                             DUP 2 ;
                             GET 13 ;
                             IF_NONE
                               {}
                               { DUP 2 ; DIG 2 ; GET 5 ; DIG 2 ; UPDATE 13 ; UPDATE 5 } ;
                             DUP 2 ;
                             GET 15 ;
                             IF_NONE
                               {}
                               { DUP 2 ; DIG 2 ; GET 5 ; DIG 2 ; UPDATE 15 ; UPDATE 5 } ;
                             DUP 2 ;
                             GET 17 ;
                             IF_NONE
                               {}
                               { DUP 2 ; DIG 2 ; GET 5 ; DIG 2 ; UPDATE 17 ; UPDATE 5 } ;
                             DUP 2 ;
                             GET 19 ;
                             IF_NONE
                               {}
                               { DUP 2 ; DIG 2 ; GET 5 ; DIG 2 ; UPDATE 19 ; UPDATE 5 } ;
                             DUP 2 ;
                             GET 21 ;
                             IF_NONE
                               {}
                               { DUP 2 ; DIG 2 ; GET 5 ; DIG 2 ; UPDATE 21 ; UPDATE 5 } ;
                             SWAP ;
                             GET 22 ;
                             IF_NONE
                               {}
                               { DUP 2 ; DIG 2 ; GET 5 ; DIG 2 ; UPDATE 22 ; UPDATE 5 } }
                           { SWAP ; DUP ; GET 3 ; DIG 2 ; SOME ; UPDATE 2 ; UPDATE 3 } } ;
                     SWAP } }
               { DIG 4 ;
                 DIG 5 ;
                 DIG 6 ;
                 DIG 7 ;
                 DIG 8 ;
                 DIG 11 ;
                 DROP 6 ;
                 IF_LEFT
                   { DIG 4 ;
                     DIG 11 ;
                     DIG 12 ;
                     DROP 3 ;
                     SWAP ;
                     DUP ;
                     DUP 3 ;
                     PAIR ;
                     DUP 6 ;
                     SWAP ;
                     EXEC ;
                     PUSH string "SLICE_AUCTION_NO_RESOLVING" ;
                     DIG 11 ;
                     DUP 3 ;
                     GET 7 ;
                     CAR ;
                     COMPARE ;
                     EQ ;
                     IF { DROP } { FAILWITH } ;
                     PUSH string "SLICE_AUCTION_LIVE" ;
                     NOW ;
                     DUP 3 ;
                     GET 7 ;
                     GET 3 ;
                     COMPARE ;
                     LT ;
                     IF { DROP } { FAILWITH } ;
                     NIL operation ;
                     DUP 2 ;
                     GET 7 ;
                     GET 6 ;
                     DUP 3 ;
                     GET 3 ;
                     PAIR ;
                     DIG 6 ;
                     SWAP ;
                     EXEC ;
                     CONS ;
                     DUP 2 ;
                     GET 7 ;
                     GET 6 ;
                     DUP 3 ;
                     PAIR ;
                     PAIR ;
                     DIG 4 ;
                     SWAP ;
                     EXEC ;
                     PUSH nat 0 ;
                     DUP 4 ;
                     DUP 4 ;
                     GET 7 ;
                     GET 5 ;
                     DIG 10 ;
                     SWAP ;
                     EXEC ;
                     DUP 7 ;
                     DIG 2 ;
                     SWAP ;
                     PAIR ;
                     DIG 7 ;
                     SWAP ;
                     EXEC ;
                     DUP ;
                     CAR ;
                     CAR ;
                     DUG 2 ;
                     CAR ;
                     CDR ;
                     PAIR ;
                     VIEW "calc_royalties" (map address nat) ;
                     IF_NONE { PUSH string "option is None" ; FAILWITH } {} ;
                     ITER { UNPAIR ;
                            PUSH nat 0 ;
                            DUP 3 ;
                            COMPARE ;
                            GT ;
                            IF
                              { DIG 3 ;
                                DUP 3 ;
                                DUP 9 ;
                                SWAP ;
                                EXEC ;
                                DIG 2 ;
                                PAIR ;
                                DUP 9 ;
                                SWAP ;
                                EXEC ;
                                CONS ;
                                DUG 2 ;
                                ADD }
                              { DROP 2 } } ;
                     DIG 6 ;
                     DROP ;
                     DUP 3 ;
                     SWAP ;
                     DIG 6 ;
                     SWAP ;
                     EXEC ;
                     DIG 3 ;
                     GET 7 ;
                     GET 5 ;
                     SUB_MUTEZ ;
                     IF_NONE { PUSH string "option is None" ; FAILWITH } {} ;
                     UPDATE 13 ;
                     SWAP ;
                     DUP 2 ;
                     DIG 2 ;
                     GET 7 ;
                     DIG 5 ;
                     UPDATE 1 ;
                     UPDATE 7 ;
                     SWAP ;
                     DUP 3 ;
                     DIG 3 ;
                     GET 9 ;
                     DIG 3 ;
                     DIG 4 ;
                     SWAP ;
                     SOME ;
                     SWAP ;
                     UPDATE ;
                     UPDATE 9 }
                   { DIG 2 ;
                     DIG 3 ;
                     DIG 6 ;
                     DIG 7 ;
                     DIG 9 ;
                     DIG 10 ;
                     DROP 6 ;
                     LAMBDA
                       (pair
                         (pair
                           (lambda
                             (pair (pair address nat) (big_map string bytes)
                                   (pair address (option address))
                                   (pair address address address nat nat mutez int int
                                         nat
                                         nat
                                         nat
                                         string)
                                   (pair bool (option address))
                                   (big_map nat
                                            (pair (pair address nat) address
                                                  (map (pair address nat) nat)
                                                  (pair nat timestamp mutez address)
                                                  nat
                                                  nat
                                                  mutez
                                                  address
                                                  nat
                                                  timestamp
                                                  timestamp
                                                  bool))
                                   (big_map nat (map string bytes))
                                   (big_map (pair address nat) mutez)
                                   (big_map (pair address nat) nat)
                                   nat)
                             mutez)
                           (lambda
                             (pair nat (big_map string bytes)
                                   (pair address (option address))
                                   (pair address address address nat nat mutez int int
                                         nat
                                         nat
                                         nat
                                         string)
                                   (pair bool (option address))
                                   (big_map nat
                                            (pair (pair address nat) address
                                                  (map (pair address nat) nat)
                                                  (pair nat timestamp mutez address)
                                                  nat
                                                  nat
                                                  mutez
                                                  address
                                                  nat
                                                  timestamp
                                                  timestamp
                                                  bool))
                                   (big_map nat (map string bytes))
                                   (big_map (pair address nat) mutez)
                                   (big_map (pair address nat) nat)
                                   nat)
                             (pair (pair address nat) address
                                   (map (pair address nat) nat)
                                   (pair nat timestamp mutez address)
                                   nat
                                   nat
                                   mutez
                                   address
                                   nat
                                   timestamp
                                   timestamp
                                   bool))
                           (lambda mutez nat)
                           nat)
                         (pair
                           (pair (big_map string bytes) (pair address (option address))
                                 (pair address address address nat nat mutez int int nat
                                       nat
                                       nat
                                       string)
                                 (pair bool (option address))
                                 (big_map nat
                                          (pair (pair address nat) address
                                                (map (pair address nat) nat)
                                                (pair nat timestamp mutez address)
                                                nat
                                                nat
                                                mutez
                                                address
                                                nat
                                                timestamp
                                                timestamp
                                                bool))
                                 (big_map nat (map string bytes))
                                 (big_map (pair address nat) mutez)
                                 (big_map (pair address nat) nat)
                                 nat)
                           address
                           (list (pair address nat nat))))
                       (pair (big_map string bytes) (pair address (option address))
                             (pair address address address nat nat mutez int int nat nat
                                   nat
                                   string)
                             (pair bool (option address))
                             (big_map nat
                                      (pair (pair address nat) address
                                            (map (pair address nat) nat)
                                            (pair nat timestamp mutez address)
                                            nat
                                            nat
                                            mutez
                                            address
                                            nat
                                            timestamp
                                            timestamp
                                            bool))
                             (big_map nat (map string bytes))
                             (big_map (pair address nat) mutez)
                             (big_map (pair address nat) nat)
                             nat)
                       { UNPAIR ;
                         UNPAIR 4 ;
                         DIG 4 ;
                         UNPAIR ;
                         DUP 2 ;
                         CDR ;
                         LAMBDA
                           (pair
                             (pair (pair address (list (pair address nat nat)))
                                   (lambda
                                     (pair (pair address nat) (big_map string bytes)
                                           (pair address (option address))
                                           (pair address address address nat nat mutez
                                                 int
                                                 int
                                                 nat
                                                 nat
                                                 nat
                                                 string)
                                           (pair bool (option address))
                                           (big_map nat
                                                    (pair (pair address nat) address
                                                          (map (pair address nat) nat)
                                                          (pair nat timestamp mutez
                                                                address)
                                                          nat
                                                          nat
                                                          mutez
                                                          address
                                                          nat
                                                          timestamp
                                                          timestamp
                                                          bool))
                                           (big_map nat (map string bytes))
                                           (big_map (pair address nat) mutez)
                                           (big_map (pair address nat) nat)
                                           nat)
                                     mutez)
                                   (lambda
                                     (pair nat (big_map string bytes)
                                           (pair address (option address))
                                           (pair address address address nat nat mutez
                                                 int
                                                 int
                                                 nat
                                                 nat
                                                 nat
                                                 string)
                                           (pair bool (option address))
                                           (big_map nat
                                                    (pair (pair address nat) address
                                                          (map (pair address nat) nat)
                                                          (pair nat timestamp mutez
                                                                address)
                                                          nat
                                                          nat
                                                          mutez
                                                          address
                                                          nat
                                                          timestamp
                                                          timestamp
                                                          bool))
                                           (big_map nat (map string bytes))
                                           (big_map (pair address nat) mutez)
                                           (big_map (pair address nat) nat)
                                           nat)
                                     (pair (pair address nat) address
                                           (map (pair address nat) nat)
                                           (pair nat timestamp mutez address)
                                           nat
                                           nat
                                           mutez
                                           address
                                           nat
                                           timestamp
                                           timestamp
                                           bool))
                                   (lambda mutez nat)
                                   nat)
                             (pair
                               (pair (big_map string bytes)
                                     (pair address (option address))
                                     (pair address address address nat nat mutez int int
                                           nat
                                           nat
                                           nat
                                           string)
                                     (pair bool (option address))
                                     (big_map nat
                                              (pair (pair address nat) address
                                                    (map (pair address nat) nat)
                                                    (pair nat timestamp mutez address)
                                                    nat
                                                    nat
                                                    mutez
                                                    address
                                                    nat
                                                    timestamp
                                                    timestamp
                                                    bool))
                                     (big_map nat (map string bytes))
                                     (big_map (pair address nat) mutez)
                                     (big_map (pair address nat) nat)
                                     nat)
                               address
                               nat
                               nat))
                           (pair (big_map string bytes) (pair address (option address))
                                 (pair address address address nat nat mutez int int nat
                                       nat
                                       nat
                                       string)
                                 (pair bool (option address))
                                 (big_map nat
                                          (pair (pair address nat) address
                                                (map (pair address nat) nat)
                                                (pair nat timestamp mutez address)
                                                nat
                                                nat
                                                mutez
                                                address
                                                nat
                                                timestamp
                                                timestamp
                                                bool))
                                 (big_map nat (map string bytes))
                                 (big_map (pair address nat) mutez)
                                 (big_map (pair address nat) nat)
                                 nat)
                           { UNPAIR ;
                             UNPAIR 5 ;
                             DIG 5 ;
                             UNPAIR ;
                             DUP ;
                             DUP 3 ;
                             GET 3 ;
                             SENDER ;
                             DIG 2 ;
                             GET 15 ;
                             DUG 2 ;
                             PAIR ;
                             GET ;
                             IF_NONE
                               { SWAP ; DIG 2 ; DIG 3 ; DIG 4 ; DIG 5 ; DIG 6 ; DROP 6 }
                               { SWAP ;
                                 DUP 3 ;
                                 GET 4 ;
                                 DIG 2 ;
                                 PAIR ;
                                 DIG 2 ;
                                 CAR ;
                                 DIG 3 ;
                                 CAR ;
                                 DIG 2 ;
                                 UNPAIR ;
                                 DIG 4 ;
                                 DUP ;
                                 DUP 3 ;
                                 PAIR ;
                                 DIG 7 ;
                                 SWAP ;
                                 EXEC ;
                                 DIG 8 ;
                                 DUP 2 ;
                                 GET 7 ;
                                 CAR ;
                                 COMPARE ;
                                 EQ ;
                                 IF
                                   { DUP 2 ;
                                     DUP 4 ;
                                     DIG 6 ;
                                     PAIR ;
                                     PAIR ;
                                     DUP 7 ;
                                     SWAP ;
                                     EXEC ;
                                     DUP 3 ;
                                     DUP 5 ;
                                     DIG 7 ;
                                     PAIR ;
                                     PAIR ;
                                     DIG 6 ;
                                     SWAP ;
                                     EXEC ;
                                     DUP ;
                                     DUP 3 ;
                                     COMPARE ;
                                     NEQ ;
                                     IF
                                       { DUP 3 ;
                                         DUP 3 ;
                                         DUP 9 ;
                                         SWAP ;
                                         EXEC ;
                                         DUP 8 ;
                                         MUL ;
                                         DUP 3 ;
                                         DIG 9 ;
                                         SWAP ;
                                         EXEC ;
                                         DUP 9 ;
                                         MUL ;
                                         DIG 5 ;
                                         GET 9 ;
                                         ADD ;
                                         SUB ;
                                         ABS ;
                                         UPDATE 9 ;
                                         DUG 2 ;
                                         PUSH mutez 0 ;
                                         DIG 2 ;
                                         COMPARE ;
                                         EQ ;
                                         IF
                                           { DUP 2 ; DUP 6 ; DIG 3 ; GET 11 ; ADD ; UPDATE 11 ; SWAP }
                                           {} ;
                                         PUSH mutez 0 ;
                                         SWAP ;
                                         COMPARE ;
                                         EQ ;
                                         IF
                                           { DUP ; DIG 4 ; DIG 2 ; GET 11 ; SUB ; ABS ; UPDATE 11 }
                                           { DIG 3 ; DROP } }
                                       { SWAP ; DIG 5 ; DIG 6 ; DROP 4 } }
                                   { DIG 3 ; DIG 4 ; DIG 5 ; DIG 6 ; DIG 7 ; DROP 5 } ;
                                 DUP 2 ;
                                 DIG 2 ;
                                 GET 9 ;
                                 DIG 2 ;
                                 DIG 3 ;
                                 SWAP ;
                                 SOME ;
                                 SWAP ;
                                 UPDATE ;
                                 UPDATE 9 } } ;
                         DUP 8 ;
                         DUP 8 ;
                         DUP 8 ;
                         DUP 8 ;
                         DUP 8 ;
                         PAIR 5 ;
                         APPLY ;
                         DIG 3 ;
                         DIG 4 ;
                         DIG 5 ;
                         DIG 6 ;
                         DIG 7 ;
                         DROP 5 ;
                         DUG 2 ;
                         ITER { SWAP ; PAIR ; DUP 2 ; SWAP ; EXEC } ;
                         SWAP ;
                         DROP } ;
                     DUP 7 ;
                     DUP 7 ;
                     DUP 7 ;
                     DUP 7 ;
                     PAIR 4 ;
                     APPLY ;
                     DIG 3 ;
                     DIG 4 ;
                     DIG 5 ;
                     DIG 6 ;
                     DROP 4 ;
                     DUG 2 ;
                     ITER { SWAP ; PAIR ; DUP 2 ; SWAP ; EXEC } ;
                     SWAP ;
                     DROP } ;
                 SWAP } } ;
         PAIR } ;
  view "get_total_supply" nat nat
        { UNPAIR ;
          SWAP ;
          GET 9 ;
          SWAP ;
          GET ;
          IF_NONE { PUSH string "SLICE_UNDEFINED" ; FAILWITH } {} ;
          DUP ;
          CAR ;
          CAR ;
          SWAP ;
          CAR ;
          CDR ;
          VIEW "total_supply" nat ;
          IF_NONE { PUSH string "option is None" ; FAILWITH } {} } ;
  view "owner" unit address { CDR ; GET 3 ; CAR } ;
  view "is_owner" address bool { UNPAIR ; SWAP ; GET 3 ; CAR ; SWAP ; COMPARE ; EQ } ;
  view "next_slice_id" unit nat { CDR ; GET 16 } }