{ parameter (or

              (or

                (or

                  (or (pair %getUser (address %user) (contract (option nat)))

                      (address %declareOwnership))

                  (or (unit %claimOwnership) (unit %pause)))

                (or (or (unit %unpause) (address %addSuperuser))

                    (or (address %removeSuperuser) (address %addWhitelister))))

              (or

                (or (or (address %removeWhitelister) (list %assertReceivers address))

                    (or (list %assertTransfers (pair address (list address)))

                        (pair %assertTransferlist (nat %fromTransferListId)

                                                  (nat %toTransferListId))))

                (or

                  (or (pair %updateUser (address %user) (option %transferlistId nat))

                      (list %updateUsers (pair address (option nat))))

                  (pair %updateTransferlist (nat %transferlistId)

                                            (option %u (pair bool (set nat))))))) ;

  storage (pair (address %admin)

                (pair (address %users)

                      (pair (option %owner_candidate address)

                            (pair (bool %paused)

                                  (pair (set %superusers address)

                                        (pair (set %whitelister address)

                                              (pair

                                                (big_map %transferlists nat

                                                                        (pair

                                                                          (bool %unrestricted)

                                                                          (set %allowedTransferlists nat)))

                                                (big_map %metadata string bytes)))))))) ;

  code { LAMBDA

           (pair string bool)

           bool

           { UNPAIR 2 ;

             PUSH unit Unit ;

             DUP 3 ;

             NOT ;

             IF

               { PUSH bool True ; SWAP ; DROP }

               { PUSH string "CONTRACT_PAUSED" ; FAILWITH } ;

             DUG 2 ;

             DROP 2 } ;

         LAMBDA

           (pair string

                 (pair

                   (big_map nat

                            (pair (bool %unrestricted) (set %allowedTransferlists nat)))

                   (pair address address)))

           bool

           { UNPAIR 4 ;

             PUSH unit Unit ;

             PUSH bool True ;

             DUP 5 ;

             DUP 7 ;

             VIEW "getopt" (option nat) ;

             IF_NONE

               { PUSH string "USER_GETOPT_INTERNAL_ERROR" ; FAILWITH }

               { DUP ;

                 IF_NONE

                   { PUSH bool False ; DIP { DIG 1 ; DROP } ; DUG 1 }

                   { DUP 6 ;

                     DUP 2 ;

                     GET ;

                     IF_NONE

                       { PUSH bool False ; DIP { DIG 2 ; DROP } ; DUG 2 }

                       { DUP ; CAR ; DIP { DIG 3 ; DROP } ; DUG 3 ; DROP } ;

                     DROP } ;

                 DROP } ;

             DUP ;

             DIP { DIG 1 ; DROP } ;

             DUG 1 ;

             DROP ;

             DUG 4 ;

             DROP 4 } ;

         NIL operation ;

         DIG 3 ;

         UNPAIR ;

         DIP { UNPAIR 8 } ;

         IF_LEFT

           { IF_LEFT

               { IF_LEFT

                   { IF_LEFT

                       { UNPAIR ;

                         NONE nat ;

                         DUP 5 ;

                         DUP 3 ;

                         VIEW "getopt" (option nat) ;

                         IF_NONE

                           { PUSH string "USER_GETOPT_INTERNAL_ERROR" ; FAILWITH }

                           { DUP ; DIP { DIG 1 ; DROP } ; DUG 1 ; DROP } ;

                         DUP 12 ;

                         DUP 4 ;

                         AMOUNT ;

                         DUP 4 ;

                         TRANSFER_TOKENS ;

                         CONS ;

                         DIP { DIG 11 ; DROP } ;

                         DUG 11 ;

                         DROP 3 ;

                         PAIR 8 ;

                         DIG 1 ;

                         PAIR }

                       { DUP 2 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP ;

                         SOME ;

                         DIP { DIG 3 ; DROP } ;

                         DUG 3 ;

                         DROP ;

                         PAIR 8 ;

                         DIG 1 ;

                         PAIR } }

                   { IF_LEFT

                       { DROP ;

                         DUP 3 ;

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

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 3 ;

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

                         SWAP ;

                         DROP ;

                         NONE address ;

                         DIP { DIG 2 ; DROP } ;

                         DUG 2 ;

                         PAIR 8 ;

                         DIG 1 ;

                         PAIR }

                       { DROP ;

                         DUP ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 4 ;

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

                         PUSH bool True ;

                         DIP { DIG 3 ; DROP } ;

                         DUG 3 ;

                         PAIR 8 ;

                         DIG 1 ;

                         PAIR } } }

               { IF_LEFT

                   { IF_LEFT

                       { DROP ;

                         DUP ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 4 ;

                         NOT ;

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

                         PUSH bool False ;

                         DIP { DIG 3 ; DROP } ;

                         DUG 3 ;

                         PAIR 8 ;

                         DIG 1 ;

                         PAIR }

                       { DUP 2 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DIG 5 ;

                         PUSH bool True ;

                         DUP 3 ;

                         UPDATE ;

                         DUG 5 ;

                         DROP ;

                         PAIR 8 ;

                         DIG 1 ;

                         PAIR } }

                   { IF_LEFT

                       { DUP 2 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DIG 5 ;

                         PUSH bool False ;

                         DUP 3 ;

                         UPDATE ;

                         DUG 5 ;

                         DROP ;

                         PAIR 8 ;

                         DIG 1 ;

                         PAIR }

                       { DUP 2 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 7 ;

                         DUP 2 ;

                         MEM ;

                         IF

                           { PUSH string "whitelister" ;

                             PUSH string "KeyExists" ;

                             PAIR ;

                             FAILWITH }

                           { DUP 7 ; PUSH bool True ; DUP 3 ; UPDATE ; DIP { DIG 6 ; DROP } ; DUG 6 } ;

                         DROP ;

                         PAIR 8 ;

                         DIG 1 ;

                         PAIR } } } }

           { IF_LEFT

               { IF_LEFT

                   { IF_LEFT

                       { DUP 2 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         NOT ;

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

                         DUP 7 ;

                         PUSH bool False ;

                         DUP 3 ;

                         UPDATE ;

                         DIP { DIG 6 ; DROP } ;

                         DUG 6 ;

                         DROP ;

                         PAIR 8 ;

                         DIG 1 ;

                         PAIR }

                       { DUP ;

                         ITER { DUP 12 ;

                                DUP 2 ;

                                DUP 6 ;

                                PAIR ;

                                DUP 11 ;

                                PAIR ;

                                PUSH string "USER_GETOPT_INTERNAL_ERROR" ;

                                PAIR ;

                                EXEC ;

                                NOT ;

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

                                DROP } ;

                         DROP ;

                         PAIR 8 ;

                         DIG 1 ;

                         PAIR } }

                   { IF_LEFT

                       { DUP ;

                         ITER { DUP ;

                                CAR ;

                                DUP 2 ;

                                CDR ;

                                DUP ;

                                ITER { SELF_ADDRESS ;

                                       DUP 2 ;

                                       DUP 5 ;

                                       PAIR ;

                                       SENDER ;

                                       PAIR ;

                                       VIEW "assertTransfer" string ;

                                       IF_NONE

                                         { PUSH string "INTERNAL_ERROR" ; FAILWITH }

                                         { PUSH string "" ;

                                           DUP 2 ;

                                           COMPARE ;

                                           NEQ ;

                                           IF { DUP ; FAILWITH } {} ;

                                           DROP } ;

                                       DROP } ;

                                DROP 3 } ;

                         DROP ;

                         PAIR 8 ;

                         DIG 1 ;

                         PAIR }

                       { UNPAIR ;

                         SWAP ;

                         DUP 9 ;

                         DUP 3 ;

                         MEM ;

                         NOT ;

                         IF

                           { PUSH string "FROM_TRANSFERLIST_NOT_FOUND" ; FAILWITH }

                           {} ;

                         DUP 9 ;

                         DUP 2 ;

                         MEM ;

                         NOT ;

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

                         DUP 9 ;

                         DUP 3 ;

                         GET ;

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

                         CAR ;

                         NOT ;

                         IF

                           { PUSH string "FROM_INVALID_UNRESTRICTED_STATE" ; FAILWITH }

                           {} ;

                         DUP 9 ;

                         DUP 2 ;

                         GET ;

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

                         CAR ;

                         NOT ;

                         IF

                           { PUSH string "TO_INVALID_UNRESTRICTED_STATE" ; FAILWITH }

                           {} ;

                         DUP 9 ;

                         DUP 3 ;

                         GET ;

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

                         CDR ;

                         DUP 2 ;

                         MEM ;

                         NOT ;

                         IF

                           { PUSH string "TO_TRANSFERLIST_NOT_FOUND_IN_FROM" ; FAILWITH }

                           {} ;

                         DROP 2 ;

                         PAIR 8 ;

                         DIG 1 ;

                         PAIR } } }

               { IF_LEFT

                   { IF_LEFT

                       { UNPAIR ;

                         SWAP ;

                         DUP 8 ;

                         SENDER ;

                         MEM ;

                         DUP 4 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         OR ;

                         NOT ;

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

                         DUP 13 ;

                         DUP 7 ;

                         PUSH string "CONTRACT_PAUSED" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r0" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP 11 ;

                         DUP 5 ;

                         CONTRACT %update (pair address (option nat)) ;

                         IF_NONE

                           { PUSH string "update" ;

                             PUSH string "EntryNotFound" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         PUSH mutez 0 ;

                         DUP 4 ;

                         DUP 6 ;

                         PAIR ;

                         TRANSFER_TOKENS ;

                         CONS ;

                         DIP { DIG 10 ; DROP } ;

                         DUG 10 ;

                         DROP 2 ;

                         PAIR 8 ;

                         DIG 1 ;

                         PAIR }

                       { DUP 7 ;

                         SENDER ;

                         MEM ;

                         DUP 3 ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         OR ;

                         NOT ;

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

                         DUP 12 ;

                         DUP 6 ;

                         PUSH string "CONTRACT_PAUSED" ;

                         PAIR ;

                         EXEC ;

                         NOT ;

                         IF

                           { PUSH string "r1" ;

                             PUSH string "InvalidCondition" ;

                             PAIR ;

                             FAILWITH }

                           {} ;

                         DUP ;

                         ITER { DUP ;

                                CAR ;

                                DUP 2 ;

                                CDR ;

                                DUP 13 ;

                                DUP 7 ;

                                CONTRACT %update (pair address (option nat)) ;

                                IF_NONE

                                  { PUSH string "update" ;

                                    PUSH string "EntryNotFound" ;

                                    PAIR ;

                                    FAILWITH }

                                  {} ;

                                PUSH mutez 0 ;

                                DUP 4 ;

                                DUP 6 ;

                                PAIR ;

                                TRANSFER_TOKENS ;

                                CONS ;

                                DIP { DIG 12 ; DROP } ;

                                DUG 12 ;

                                DROP 3 } ;

                         DROP ;

                         PAIR 8 ;

                         DIG 1 ;

                         PAIR } }

                   { UNPAIR ;

                     SWAP ;

                     DUP 3 ;

                     SENDER ;

                     COMPARE ;

                     EQ ;

                     NOT ;

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

                     DUP 13 ;

                     DUP 7 ;

                     PUSH string "CONTRACT_PAUSED" ;

                     PAIR ;

                     EXEC ;

                     NOT ;

                     IF

                       { PUSH string "r2" ; PUSH string "InvalidCondition" ; PAIR ; FAILWITH }

                       {} ;

                     DUP ;

                     IF_NONE

                       { DIG 8 ; NONE (pair bool (set nat)) ; DUP 4 ; UPDATE ; DUG 8 }

                       { DUP ; CDR ; DUP 2 ; CAR ; PAIR ; DIG 10 ; DUP 2 ; SOME ; DUP 6 ; UPDATE ; DUG 10 ; DROP 2 } ;

                     DROP 2 ;

                     PAIR 8 ;

                     DIG 1 ;

                     PAIR } } } ;

         DIP { DROP 2 } } ;

  view "assertTransfer" (pair address (pair address address)) string

        { UNPAIR ;

          DIP { CDR ; UNPAIR ; SWAP ; CDR ; CDR ; UNPAIR ; SWAP ; CDR ; UNPAIR ; SWAP ; DROP } ;

          UNPAIR 3 ;

          UNIT ;

          PUSH string "" ;

          NONE nat ;

          NONE nat ;

          PUSH bool False ;

          DUP 11 ;

          DUP 8 ;

          VIEW "getopt" (option nat) ;

          IF_NONE

            { PUSH string "USER_GETOPT_INTERNAL_ERROR" ; FAILWITH }

            { DUP ;

              DIP { DIG 3 ; DROP } ;

              DUG 3 ;

              DUP ;

              IF_NONE

                { PUSH bool True ; DIP { DIG 1 ; DROP } ; DUG 1 }

                { DUP 11 ;

                  DUP 2 ;

                  GET ;

                  IF_NONE

                    { PUSH bool True ; DIP { DIG 2 ; DROP } ; DUG 2 }

                    { DUP ; CAR ; NOT ; DIP { DIG 3 ; DROP } ; DUG 3 ; DROP } ;

                  DROP } ;

              DROP } ;

          DUP ;

          IF

            { PUSH string "FROM_RESTRICTED" ; DIP { DIG 3 ; DROP } ; DUG 3 }

            { PUSH bool False ;

              DUP 12 ;

              DUP 10 ;

              VIEW "getopt" (option nat) ;

              IF_NONE

                { PUSH string "USER_GETOPT_INTERNAL_ERROR" ; FAILWITH }

                { DUP ;

                  DIP { DIG 3 ; DROP } ;

                  DUG 3 ;

                  DUP ;

                  IF_NONE

                    { PUSH bool True ; DIP { DIG 1 ; DROP } ; DUG 1 }

                    { DUP 12 ;

                      DUP 2 ;

                      GET ;

                      IF_NONE

                        { PUSH bool True ; DIP { DIG 2 ; DROP } ; DUG 2 }

                        { DUP ; CAR ; NOT ; DIP { DIG 3 ; DROP } ; DUG 3 ; DROP } ;

                      DROP } ;

                  DROP } ;

              DUP ;

              IF

                { PUSH string "TO_RESTRICTED" ; DIP { DIG 4 ; DROP } ; DUG 4 }

                { DUP 11 ;

                  DUP 8 ;

                  MEM ;

                  NOT ;

                  IF

                    { DUP 4 ;

                      IF_NONE

                        { PUSH string "INTERNAL_ERROR" ; FAILWITH }

                        { DUP 4 ;

                          IF_NONE

                            { PUSH string "INTERNAL_ERROR" ; FAILWITH }

                            { DUP 12 ;

                              DUP 3 ;

                              GET ;

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

                              CDR ;

                              DUP ;

                              DUP 3 ;

                              MEM ;

                              NOT ;

                              IF

                                { PUSH string "TO_NOT_ALLOWED" ;

                                  DIP { DIG 7 ; DROP } ;

                                  DUG 7 }

                                {} ;

                              DROP 2 } ;

                          DROP } }

                    {} } ;

              DROP } ;

          DUP 4 ;

          DIP { DIG 4 ; DROP } ;

          DUG 4 ;

          DROP 4 ;

          DIP { DROP 6 } } }