{ parameter (or

              (or

                (or

                  (or (or (list %clean_holders address) (unit %restrict_to_whitelist))

                      (or (unit %open_to_all) (address %declare_ownership)))

                  (or (or (unit %claim_ownership) (unit %pause))

                      (or (unit %unpause) (bool %manage_rafle))))

                (or

                  (or (or (mutez %set_token_price) (nat %set_total_supply))

                      (or (pair %set_metadata (string %k) (option %d bytes))

                          (list %adds_to_whitelist address)))

                  (or

                    (or (list %removes_from_whitelist address) (address %set_collection))

                    (or (address %add_orders_operator) (address %remove_orders_operator)))))

              (or

                (or (or (address %do_create_order) (unit %create_order))

                    (or (address %create_order_for) (address %confirm_order)))

                (or

                  (or (pair %repay_order (address %target_address) (mutez %tez_amount))

                      (pair %drop (address %todrop) (nat %quantity)))

                  (pair %collect (address %collector) (mutez %amount))))) ;

  storage (pair (address %owner) (address %collection) (mutez %token_price)

                (nat %total_supply)

                (nat %current_supply)

                (option %owner_candidate address)

                (bool %paused)

                (bool %rafle_is_closed)

                (bool %white_list_state)

                (big_map %holders address

                                  (pair (nat %holder_token_count) (int %holder_status)))

                (big_map %orders_operator address unit)

                (big_map %white_list address unit)

                (big_map %metadata string bytes)) ;

  code { LAMBDA

           nat

           bool

           { PUSH unit Unit ;

             PUSH nat 1 ;

             DUP 3 ;

             COMPARE ;

             EQ ;

             IF

               { PUSH bool True }

               { PUSH nat 2 ; DUP 3 ; COMPARE ; EQ ; IF { PUSH bool True } { PUSH bool False } } ;

             IF

               { PUSH bool True }

               { PUSH nat 4 ; DUP 3 ; COMPARE ; EQ ; IF { PUSH bool True } { PUSH bool False } } ;

             IF

               { PUSH bool True }

               { PUSH nat 10 ; DUP 3 ; COMPARE ; EQ ; IF { PUSH bool True } { PUSH bool False } } ;

             IF { PUSH bool True ; SWAP ; DROP 1 } { PUSH bool False ; SWAP ; DROP 1 } ;

             SWAP ;

             DROP 1 } ;

         NIL operation ;

         DIG 2 ;

         UNPAIR ;

         DIP 1 { UNPAIR 13 } ;

         IF_LEFT

           { IF_LEFT

               { IF_LEFT

                   { IF_LEFT

                       { IF_LEFT

                           { DUP 2 ;

                             SENDER ;

                             COMPARE ;

                             EQ ;

                             NOT ;

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

                             DUP ;

                             ITER { DUP 12 ;

                                    DUP 2 ;

                                    GET ;

                                    IF_NONE

                                      { PUSH string "HOLDER_UNKNOWN" ; FAILWITH }

                                      { PUSH int 0 ;

                                        DUP 2 ;

                                        GET 2 ;

                                        COMPARE ;

                                        EQ ;

                                        IF

                                          { PUSH string "HOLDER_STATUS_ERROR" ; FAILWITH }

                                          {} ;

                                        DUP 13 ;

                                        NONE (pair nat int) ;

                                        DUP 4 ;

                                        UPDATE ;

                                        DIP 1 { DIG 12 ; DROP 1 } ;

                                        DUG 12 ;

                                        DROP 1 } ;

                                    DROP 1 } ;

                             DROP 1 ;

                             PAIR 13 ;

                             SWAP ;

                             PAIR }

                           { DROP 1 ;

                             DUP ;

                             SENDER ;

                             COMPARE ;

                             EQ ;

                             NOT ;

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

                             PUSH bool True ;

                             DIP 1 { DIG 8 ; DROP 1 } ;

                             DUG 8 ;

                             PAIR 13 ;

                             SWAP ;

                             PAIR } }

                       { IF_LEFT

                           { DROP 1 ;

                             DUP ;

                             SENDER ;

                             COMPARE ;

                             EQ ;

                             NOT ;

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

                             PUSH bool False ;

                             DIP 1 { DIG 8 ; DROP 1 } ;

                             DUG 8 ;

                             PAIR 13 ;

                             SWAP ;

                             PAIR }

                           { DUP 2 ;

                             SENDER ;

                             COMPARE ;

                             EQ ;

                             NOT ;

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

                             DUP ;

                             SOME ;

                             DIP 1 { DIG 6 ; DROP 1 } ;

                             DUG 6 ;

                             DROP 1 ;

                             PAIR 13 ;

                             SWAP ;

                             PAIR } } }

                   { IF_LEFT

                       { IF_LEFT

                           { DROP 1 ;

                             DUP 6 ;

                             IF_NONE

                               { PUSH bool False }

                               { SENDER ; DUP 2 ; COMPARE ; EQ ; SWAP ; DROP 1 } ;

                             NOT ;

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

                             SENDER ;

                             SWAP ;

                             DROP 1 ;

                             NONE address ;

                             DIP 1 { DIG 5 ; DROP 1 } ;

                             DUG 5 ;

                             PAIR 13 ;

                             SWAP ;

                             PAIR }

                           { DROP 1 ;

                             DUP ;

                             SENDER ;

                             COMPARE ;

                             EQ ;

                             NOT ;

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

                             DUP 7 ;

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

                             PUSH bool True ;

                             DIP 1 { DIG 6 ; DROP 1 } ;

                             DUG 6 ;

                             PAIR 13 ;

                             SWAP ;

                             PAIR } }

                       { IF_LEFT

                           { DROP 1 ;

                             DUP ;

                             SENDER ;

                             COMPARE ;

                             EQ ;

                             NOT ;

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

                             DUP 7 ;

                             NOT ;

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

                             PUSH bool False ;

                             DIP 1 { DIG 6 ; DROP 1 } ;

                             DUG 6 ;

                             PAIR 13 ;

                             SWAP ;

                             PAIR }

                           { DUP 2 ;

                             SENDER ;

                             COMPARE ;

                             EQ ;

                             NOT ;

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

                             DUP 8 ;

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

                             DUP ;

                             DIP 1 { DIG 8 ; DROP 1 } ;

                             DUG 8 ;

                             DROP 1 ;

                             PAIR 13 ;

                             SWAP ;

                             PAIR } } } }

               { IF_LEFT

                   { IF_LEFT

                       { IF_LEFT

                           { DUP 2 ;

                             SENDER ;

                             COMPARE ;

                             EQ ;

                             NOT ;

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

                             DUP 8 ;

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

                             PUSH mutez 0 ;

                             DUP 2 ;

                             COMPARE ;

                             EQ ;

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

                             DUP ;

                             DIP 1 { DIG 3 ; DROP 1 } ;

                             DUG 3 ;

                             DROP 1 ;

                             PAIR 13 ;

                             SWAP ;

                             PAIR }

                           { DUP 2 ;

                             SENDER ;

                             COMPARE ;

                             EQ ;

                             NOT ;

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

                             DUP 8 ;

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

                             DUP 6 ;

                             DUP 2 ;

                             COMPARE ;

                             LT ;

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

                             PUSH nat 0 ;

                             DUP 2 ;

                             COMPARE ;

                             EQ ;

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

                             DUP ;

                             DIP 1 { DIG 4 ; DROP 1 } ;

                             DUG 4 ;

                             DROP 1 ;

                             PAIR 13 ;

                             SWAP ;

                             PAIR } }

                       { IF_LEFT

                           { UNPAIR ;

                             SWAP ;

                             DUP 3 ;

                             SENDER ;

                             COMPARE ;

                             EQ ;

                             NOT ;

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

                             DUP 9 ;

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

                             DUP 15 ;

                             DUP 2 ;

                             DUP 4 ;

                             UPDATE ;

                             DIP 1 { DIG 14 ; DROP 1 } ;

                             DUG 14 ;

                             DROP 2 ;

                             PAIR 13 ;

                             SWAP ;

                             PAIR }

                           { DUP 2 ;

                             SENDER ;

                             COMPARE ;

                             EQ ;

                             NOT ;

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

                             DUP 8 ;

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

                             DUP ;

                             ITER { DUP 14 ;

                                    DUP 2 ;

                                    MEM ;

                                    IF

                                      { PUSH string "white_list" ;

                                        PUSH string "KEY_EXISTS" ;

                                        PAIR ;

                                        FAILWITH }

                                      { DUP 14 ;

                                        PUSH unit Unit ;

                                        SOME ;

                                        DUP 3 ;

                                        UPDATE ;

                                        DIP 1 { DIG 13 ; DROP 1 } ;

                                        DUG 13 } ;

                                    DROP 1 } ;

                             DROP 1 ;

                             PAIR 13 ;

                             SWAP ;

                             PAIR } } }

                   { IF_LEFT

                       { IF_LEFT

                           { DUP 2 ;

                             SENDER ;

                             COMPARE ;

                             EQ ;

                             NOT ;

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

                             DUP 8 ;

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

                             DUP ;

                             ITER { DUP 14 ;

                                    NONE unit ;

                                    DUP 3 ;

                                    UPDATE ;

                                    DIP 1 { DIG 13 ; DROP 1 } ;

                                    DUG 13 ;

                                    DROP 1 } ;

                             DROP 1 ;

                             PAIR 13 ;

                             SWAP ;

                             PAIR }

                           { DUP 2 ;

                             SENDER ;

                             COMPARE ;

                             EQ ;

                             NOT ;

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

                             DUP 8 ;

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

                             DUP ;

                             DIP 1 { DIG 2 ; DROP 1 } ;

                             DUG 2 ;

                             DROP 1 ;

                             PAIR 13 ;

                             SWAP ;

                             PAIR } }

                       { IF_LEFT

                           { DUP 2 ;

                             SENDER ;

                             COMPARE ;

                             EQ ;

                             NOT ;

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

                             DUP 8 ;

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

                             DUP 12 ;

                             DUP 2 ;

                             MEM ;

                             IF

                               { PUSH string "orders_operator" ;

                                 PUSH string "KEY_EXISTS" ;

                                 PAIR ;

                                 FAILWITH }

                               { DUP 12 ;

                                 PUSH unit Unit ;

                                 SOME ;

                                 DUP 3 ;

                                 UPDATE ;

                                 DIP 1 { DIG 11 ; DROP 1 } ;

                                 DUG 11 } ;

                             DROP 1 ;

                             PAIR 13 ;

                             SWAP ;

                             PAIR }

                           { DUP 2 ;

                             SENDER ;

                             COMPARE ;

                             EQ ;

                             NOT ;

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

                             DUP 8 ;

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

                             DUP 12 ;

                             NONE unit ;

                             DUP 3 ;

                             UPDATE ;

                             DIP 1 { DIG 11 ; DROP 1 } ;

                             DUG 11 ;

                             DROP 1 ;

                             PAIR 13 ;

                             SWAP ;

                             PAIR } } } } }

           { IF_LEFT

               { IF_LEFT

                   { IF_LEFT

                       { SELF_ADDRESS ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 4 ;

                         AMOUNT ;

                         COMPARE ;

                         LT ;

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

                         DUP 8 ;

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

                         DUP 9 ;

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

                         DUP 11 ;

                         DUP 2 ;

                         GET ;

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

                         DUP 4 ;

                         AMOUNT ;

                         EDIV ;

                         PUSH nat 0 ;

                         PUSH mutez 0 ;

                         DUP 3 ;

                         IF_NONE

                           {}

                           { DUP ;

                             GET 1 ;

                             DIP 1 { DIG 2 ; DROP 1 } ;

                             DUG 2 ;

                             DUP ;

                             GET 2 ;

                             DIP 1 { SWAP ; DROP 1 } ;

                             SWAP ;

                             DROP 1 } ;

                         PUSH mutez 0 ;

                         DUP 2 ;

                         COMPARE ;

                         GT ;

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

                         DUP 8 ;

                         DUP 10 ;

                         DUP 4 ;

                         ADD ;

                         COMPARE ;

                         GT ;

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

                         DUP 19 ;

                         DUP 3 ;

                         EXEC ;

                         NOT ;

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

                         DUP 13 ;

                         IF

                           { DUP 16 ;

                             DUP 5 ;

                             MEM ;

                             NOT ;

                             IF

                               { PUSH string "WHITE_LIST_ACCESS_RESTRICTION" ; FAILWITH }

                               {} }

                           {} ;

                         DUP 14 ;

                         DUP 5 ;

                         MEM ;

                         IF

                           { PUSH string "holders" ;

                             PUSH string "KEY_EXISTS" ;

                             PAIR ;

                             FAILWITH }

                           { DUP 14 ;

                             PUSH int 0 ;

                             DUP 4 ;

                             PAIR ;

                             SOME ;

                             DUP 6 ;

                             UPDATE ;

                             DIP 1 { DIG 13 ; DROP 1 } ;

                             DUG 13 } ;

                         DUP 2 ;

                         DUP 10 ;

                         ADD ;

                         DIP 1 { DIG 8 ; DROP 1 } ;

                         DUG 8 ;

                         DROP 4 ;

                         PAIR 13 ;

                         SWAP ;

                         PAIR }

                       { DROP 1 ;

                         NIL operation ;

                         NIL operation ;

                         DUP 16 ;

                         ITER { CONS } ;

                         SELF_ADDRESS ;

                         CONTRACT %do_create_order address ;

                         IF_NONE

                           { PUSH string "do_create_order" ;

                             PUSH string "ENTRY_NOT_FOUND" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         AMOUNT ;

                         SENDER ;

                         TRANSFER_TOKENS ;

                         CONS ;

                         ITER { CONS } ;

                         DIP 1 { DIG 13 ; DROP 1 } ;

                         DUG 13 ;

                         PAIR 13 ;

                         SWAP ;

                         PAIR } }

                   { IF_LEFT

                       { DUP 12 ;

                         SENDER ;

                         MEM ;

                         NOT ;

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

                         NIL operation ;

                         NIL operation ;

                         DUP 17 ;

                         ITER { CONS } ;

                         SELF_ADDRESS ;

                         CONTRACT %do_create_order address ;

                         IF_NONE

                           { PUSH string "do_create_order" ;

                             PUSH string "ENTRY_NOT_FOUND" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         AMOUNT ;

                         DUP 5 ;

                         TRANSFER_TOKENS ;

                         CONS ;

                         ITER { CONS } ;

                         DIP 1 { DIG 14 ; DROP 1 } ;

                         DUG 14 ;

                         DROP 1 ;

                         PAIR 13 ;

                         SWAP ;

                         PAIR }

                       { DUP 2 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 8 ;

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

                         DUP 11 ;

                         DUP 2 ;

                         MEM ;

                         IF

                           { DUP 11 ;

                             DUP 2 ;

                             GET ;

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

                             PUSH nat 0 ;

                             DUP 2 ;

                             GET 1 ;

                             COMPARE ;

                             EQ ;

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

                             PUSH int 0 ;

                             DUP 2 ;

                             GET 2 ;

                             COMPARE ;

                             NEQ ;

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

                             NIL operation ;

                             NIL operation ;

                             DUP 18 ;

                             ITER { CONS } ;

                             DUP 6 ;

                             CONTRACT %mint (pair address nat) ;

                             IF_NONE

                               { PUSH string "mint" ;

                                 PUSH string "ENTRY_NOT_FOUND" ;

                                 PAIR ;

                                 FAILWITH }

                               {} ;

                             PUSH mutez 0 ;

                             DUP 5 ;

                             GET 1 ;

                             DUP 7 ;

                             PAIR ;

                             TRANSFER_TOKENS ;

                             CONS ;

                             ITER { CONS } ;

                             DIP 1 { DIG 15 ; DROP 1 } ;

                             DUG 15 ;

                             DUP 12 ;

                             DUP 13 ;

                             DUP 4 ;

                             GET ;

                             IF_NONE

                               { PUSH string "holders" ;

                                 PUSH string "ASSET_NOT_FOUND" ;

                                 PAIR ;

                                 FAILWITH }

                               {} ;

                             UNPAIR ;

                             SWAP ;

                             DROP 1 ;

                             PUSH int 1 ;

                             SWAP ;

                             PAIR ;

                             SOME ;

                             DUP 4 ;

                             UPDATE ;

                             DIP 1 { DIG 11 ; DROP 1 } ;

                             DUG 11 ;

                             DROP 1 }

                           { PUSH string "CONFIRM_ORDER_ERROR" ; FAILWITH } ;

                         DROP 1 ;

                         PAIR 13 ;

                         SWAP ;

                         PAIR } } }

               { IF_LEFT

                   { IF_LEFT

                       { UNPAIR ;

                         SWAP ;

                         DUP 3 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 9 ;

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

                         DUP 12 ;

                         DUP 3 ;

                         MEM ;

                         IF

                           { DUP 12 ;

                             DUP 3 ;

                             GET ;

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

                             PUSH nat 0 ;

                             DUP 2 ;

                             GET 1 ;

                             COMPARE ;

                             EQ ;

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

                             PUSH int 0 ;

                             DUP 2 ;

                             GET 2 ;

                             COMPARE ;

                             NEQ ;

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

                             NIL operation ;

                             NIL operation ;

                             DUP 19 ;

                             ITER { CONS } ;

                             DUP 5 ;

                             CONTRACT unit ;

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

                             DUP 5 ;

                             UNIT ;

                             TRANSFER_TOKENS ;

                             CONS ;

                             ITER { CONS } ;

                             DIP 1 { DIG 16 ; DROP 1 } ;

                             DUG 16 ;

                             DUP ;

                             GET 1 ;

                             INT ;

                             DUP 9 ;

                             INT ;

                             SUB ;

                             ISNAT ;

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

                             DUP ;

                             DIP 1 { DIG 8 ; DROP 1 } ;

                             DUG 8 ;

                             DUP 14 ;

                             DUP 15 ;

                             DUP 6 ;

                             GET ;

                             IF_NONE

                               { PUSH string "holders" ;

                                 PUSH string "ASSET_NOT_FOUND" ;

                                 PAIR ;

                                 FAILWITH }

                               {} ;

                             UNPAIR ;

                             SWAP ;

                             DROP 1 ;

                             PUSH int 2 ;

                             SWAP ;

                             PAIR ;

                             SOME ;

                             DUP 6 ;

                             UPDATE ;

                             DIP 1 { DIG 13 ; DROP 1 } ;

                             DUG 13 ;

                             DROP 2 }

                           { PUSH string "REPAY_HOLDER_ERROR" ; FAILWITH } ;

                         DROP 2 ;

                         PAIR 13 ;

                         SWAP ;

                         PAIR }

                       { UNPAIR ;

                         SWAP ;

                         DUP 3 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 9 ;

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

                         DUP 6 ;

                         DUP 8 ;

                         DUP 3 ;

                         ADD ;

                         COMPARE ;

                         GT ;

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

                         NIL operation ;

                         NIL operation ;

                         DUP 18 ;

                         ITER { CONS } ;

                         DUP 6 ;

                         CONTRACT %mint (pair address nat) ;

                         IF_NONE

                           { PUSH string "mint" ;

                             PUSH string "ENTRY_NOT_FOUND" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         PUSH mutez 0 ;

                         DUP 5 ;

                         DUP 7 ;

                         PAIR ;

                         TRANSFER_TOKENS ;

                         CONS ;

                         ITER { CONS } ;

                         DIP 1 { DIG 15 ; DROP 1 } ;

                         DUG 15 ;

                         DUP ;

                         DUP 8 ;

                         ADD ;

                         DIP 1 { DIG 6 ; DROP 1 } ;

                         DUG 6 ;

                         DROP 2 ;

                         PAIR 13 ;

                         SWAP ;

                         PAIR } }

                   { UNPAIR ;

                     SWAP ;

                     DUP 3 ;

                     SENDER ;

                     COMPARE ;

                     EQ ;

                     NOT ;

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

                     NIL operation ;

                     NIL operation ;

                     DUP 18 ;

                     ITER { CONS } ;

                     DUP 4 ;

                     CONTRACT unit ;

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

                     DUP 4 ;

                     UNIT ;

                     TRANSFER_TOKENS ;

                     CONS ;

                     ITER { CONS } ;

                     DIP 1 { DIG 15 ; DROP 1 } ;

                     DUG 15 ;

                     DROP 2 ;

                     PAIR 13 ;

                     SWAP ;

                     PAIR } } } ;

         DIP 1 { DROP 1 } } ;

  view "is_white_list" address bool