parameter (or

            (or

              (or

                (or (pair %burn (int %amount) (address %fromAddr))

                    (or (nat %claimSale)

                        (pair %cvrDrop (list %addresses address) (int %amount))))

                (or (pair %dispatchRoyalties (list %addresses address) (nat %amount))

                    (or (address %getAdministrator)

                        (pair %getBalance (address %owner) (address %target)))))

              (or

                (or (address %getCirculatingSupply)

                    (or (address %getFactor) (address %getManager)))

                (or (or (address %getSaleLimit) (address %getSaleStatus))

                    (or (address %getSoldToken) (address %getSupplyLimit)))))

            (or

              (or

                (or (address %getTransferStatus)

                    (or (int %increaseSaleLimit) (address %lockAddress)))

                (or

                  (or (pair %mint (int %amount) (address %toAddr))

                      (pair %offchainSale (address %address) (int %amount)))

                  (or (unit %pauseSale) (unit %pauseTransfer))))

              (or (or (unit %resumeSale) (or (unit %resumeTransfer) (unit %sale)))

                  (or (or (address %setAdministrator) (address %setManager))

                      (or

                        (pair %transfer (int %amount)

                                        (pair (address %fromAddr) (address %toAddr)))

                        (address %unlockAddress))))));

storage (pair

          (pair

            (pair

              (pair (address %administrator)

                    (big_map %balances address (pair (int %balance) (bool %lock))))

              (pair (int %circulatingSupply) (address %covir)))

            (pair (pair (int %factor) (address %octopus))

                  (pair (address %owner) (int %ratio))))

          (pair

            (pair (pair (int %saleLimit) (address %saleManager))

                  (pair (bool %saleStatus) (int %soldToken)))

            (pair (pair (int %supplyLimit) (string %tokenName))

                  (pair (string %tokenSymbol) (bool %transferStatus)))));

code { DUP ;

       CDR ;

       SWAP ;

       CAR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { IF_LEFT

                     { DUP ;

                       CDR ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF

                         {}

                         { PUSH string "WrongCondition: params.fromAddr == sp.sender" ;

                           FAILWITH } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       { CAR ; CAR ; CAR ; CDR } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CDR ;

                       MEM ;

                       IF

                         {}

                         { PUSH string "WrongCondition: self.data.balances.contains(params.fromAddr)" ;

                           FAILWITH } ;

                       DUP ;

                       CAR ;

                       DIG 2 ;

                       DUP ;

                       DUG 3 ;

                       { CAR ; CAR ; CAR ; CDR } ;

                       DIG 2 ;

                       DUP ;

                       DUG 3 ;

                       CDR ;

                       GET ;

                       { IF_NONE { PUSH string "Get-item:23" ; FAILWITH } {} } ;

                       CAR ;

                       COMPARE ;

                       GE ;

                       IF

                         {}

                         { PUSH string "WrongCondition: self.data.balances[params.fromAddr].balance >= params.amount" ;

                           FAILWITH } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       DIG 6 ;

                       DUP ;

                       DUG 7 ;

                       CDR ;

                       DUP ;

                       DUG 2 ;

                       GET ;

                       { IF_NONE { PUSH string "set_in_top-any" ; FAILWITH } {} } ;

                       CDR ;

                       DIG 7 ;

                       DUP ;

                       DUG 8 ;

                       CAR ;

                       DIG 9 ;

                       DUP ;

                       DUG 10 ;

                       { CAR ; CAR ; CAR ; CDR } ;

                       DIG 9 ;

                       DUP ;

                       DUG 10 ;

                       CDR ;

                       GET ;

                       { IF_NONE { PUSH string "Get-item:23" ; FAILWITH } {} } ;

                       CAR ;

                       SUB ;

                       PAIR ;

                       SOME ;

                       SWAP ;

                       UPDATE ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       DUG 2 ;

                       SWAP ;

                       DROP ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       CAR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       { CDR ; CDR } ;

                       DIG 4 ;

                       DUP ;

                       DUG 5 ;

                       CAR ;

                       DIG 6 ;

                       DUP ;

                       DUG 7 ;

                       { CAR ; CAR ; CDR ; CAR } ;

                       SUB ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       PAIR ;

                       PAIR ;

                       DUG 2 ;

                       SWAP ;

                       DROP ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CAR ;

                       SWAP ;

                       CDR ;

                       DUP ;

                       CDR ;

                       SWAP ;

                       { CAR ; CDR } ;

                       DIG 4 ;

                       DUP ;

                       DUG 5 ;

                       CAR ;

                       DIG 6 ;

                       DUP ;

                       DUG 7 ;

                       { CDR ; CDR ; CAR ; CAR } ;

                       SUB ;

                       PAIR ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       SWAP ;

                       PAIR ;

                       DUG 2 ;

                       DROP 2 ;

                       NIL operation }

                     { IF_LEFT

                         { SWAP ;

                           DUP ;

                           DUG 2 ;

                           { CAR ; CAR ; CAR ; CAR } ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           IF

                             {}

                             { PUSH string "WrongCondition: sp.sender == self.data.administrator" ;

                               FAILWITH } ;

                           DUP ;

                           PUSH mutez 1 ;

                           MUL ;

                           BALANCE ;

                           COMPARE ;

                           GT ;

                           IF

                             {}

                             { PUSH string "WrongCondition: sp.balance > sp.mutez(params.amount)" ;

                               FAILWITH } ;

                           NIL operation ;

                           DIG 2 ;

                           DUP ;

                           DUG 3 ;

                           { CAR ; CDR ; CAR ; CDR } ;

                           CONTRACT unit ;

                           { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                           PUSH mutez 1 ;

                           PUSH nat 75 ;

                           PUSH nat 100 ;

                           DIG 5 ;

                           DUP ;

                           DUG 6 ;

                           EDIV ;

                           { IF_NONE

                               { PUSH string "division by zero" ; FAILWITH }

                               { CAR } } ;

                           MUL ;

                           MUL ;

                           PUSH unit Unit ;

                           TRANSFER_TOKENS ;

                           CONS ;

                           DUP ;

                           DIG 3 ;

                           DUP ;

                           DUG 4 ;

                           { CAR ; CAR ; CDR ; CDR } ;

                           CONTRACT unit ;

                           { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                           PUSH mutez 1 ;

                           PUSH nat 25 ;

                           PUSH nat 100 ;

                           DIG 6 ;

                           DUP ;

                           DUG 7 ;

                           EDIV ;

                           { IF_NONE

                               { PUSH string "division by zero" ; FAILWITH }

                               { CAR } } ;

                           MUL ;

                           MUL ;

                           PUSH unit Unit ;

                           TRANSFER_TOKENS ;

                           CONS ;

                           SWAP ;

                           DROP ;

                           SWAP ;

                           DROP }

                         { SWAP ;

                           DUP ;

                           DUG 2 ;

                           { CAR ; CAR ; CAR ; CAR } ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           IF

                             {}

                             { PUSH string "WrongCondition: sp.sender == self.data.administrator" ;

                               FAILWITH } ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           { CDR ; CDR ; CAR ; CAR } ;

                           DIG 2 ;

                           DUP ;

                           DUG 3 ;

                           { CAR ; CAR ; CDR ; CAR } ;

                           DIG 3 ;

                           DUP ;

                           DUG 4 ;

                           { CDR ; CAR ; CDR ; CDR } ;

                           DIG 4 ;

                           DUP ;

                           DUG 5 ;

                           { CDR ; CAR ; CAR ; CAR } ;

                           SUB ;

                           DIG 3 ;

                           DUP ;

                           DUG 4 ;

                           CAR ;

                           SIZE ;

                           INT ;

                           DIG 4 ;

                           DUP ;

                           DUG 5 ;

                           CDR ;

                           MUL ;

                           ADD ;

                           ADD ;

                           COMPARE ;

                           LE ;

                           IF

                             {}

                             { PUSH string "WrongCondition: (((params.amount * (sp.to_int(sp.len(params.addresses)))) + (self.data.saleLimit - self.data.soldToken)) + self.data.circulatingSupply) <= self.data.supplyLimit" ;

                               FAILWITH } ;

                           DUP ;

                           CAR ;

                           ITER { DIG 2 ;

                                  DUP ;

                                  DUG 3 ;

                                  { CAR ; CAR ; CAR ; CDR } ;

                                  SWAP ;

                                  DUP ;

                                  DUG 2 ;

                                  MEM ;

                                  IF

                                    {}

                                    { DIG 2 ;

                                      DUP ;

                                      DUG 3 ;

                                      DUP ;

                                      CDR ;

                                      SWAP ;

                                      CAR ;

                                      DUP ;

                                      CDR ;

                                      SWAP ;

                                      CAR ;

                                      DUP ;

                                      CDR ;

                                      SWAP ;

                                      CAR ;

                                      DUP ;

                                      CAR ;

                                      SWAP ;

                                      CDR ;

                                      PUSH (option (pair (int %balance) (bool %lock))) (Some (Pair 0 False)) ;

                                      DIG 6 ;

                                      DUP ;

                                      DUG 7 ;

                                      UPDATE ;

                                      SWAP ;

                                      PAIR ;

                                      PAIR ;

                                      PAIR ;

                                      PAIR ;

                                      DUG 3 ;

                                      DIG 2 ;

                                      DROP } ;

                                  DIG 2 ;

                                  DUP ;

                                  DUG 3 ;

                                  DUP ;

                                  CDR ;

                                  SWAP ;

                                  CAR ;

                                  DUP ;

                                  CDR ;

                                  SWAP ;

                                  CAR ;

                                  DUP ;

                                  CDR ;

                                  SWAP ;

                                  CAR ;

                                  DUP ;

                                  CAR ;

                                  SWAP ;

                                  CDR ;

                                  DUP ;

                                  DIG 6 ;

                                  DUP ;

                                  DUG 7 ;

                                  DUP ;

                                  DUG 2 ;

                                  GET ;

                                  { IF_NONE

                                      { PUSH string "set_in_top-any" ; FAILWITH }

                                      {} } ;

                                  CDR ;

                                  DIG 8 ;

                                  DUP ;

                                  DUG 9 ;

                                  CDR ;

                                  DIG 10 ;

                                  DUP ;

                                  DUG 11 ;

                                  { CAR ; CAR ; CAR ; CDR } ;

                                  DIG 3 ;

                                  DUP ;

                                  DUG 4 ;

                                  GET ;

                                  { IF_NONE

                                      { PUSH string "Get-item:126" ; FAILWITH }

                                      {} } ;

                                  CAR ;

                                  ADD ;

                                  PAIR ;

                                  SOME ;

                                  SWAP ;

                                  UPDATE ;

                                  SWAP ;

                                  PAIR ;

                                  PAIR ;

                                  PAIR ;

                                  PAIR ;

                                  DUG 3 ;

                                  DIG 2 ;

                                  DROP ;

                                  DIG 2 ;

                                  DUP ;

                                  DUG 3 ;

                                  DUP ;

                                  CDR ;

                                  SWAP ;

                                  CAR ;

                                  DUP ;

                                  CDR ;

                                  SWAP ;

                                  CAR ;

                                  DUP ;

                                  CAR ;

                                  SWAP ;

                                  { CDR ; CDR } ;

                                  DIG 5 ;

                                  DUP ;

                                  DUG 6 ;

                                  CDR ;

                                  DIG 7 ;

                                  DUP ;

                                  DUG 8 ;

                                  { CAR ; CAR ; CDR ; CAR } ;

                                  ADD ;

                                  PAIR ;

                                  SWAP ;

                                  PAIR ;

                                  PAIR ;

                                  PAIR ;

                                  DUG 3 ;

                                  DROP ;

                                  SWAP ;

                                  DROP } ;

                           DROP ;

                           NIL operation } } }

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       { CAR ; CAR ; CAR ; CAR } ;

                       SENDER ;

                       COMPARE ;

                       EQ ;

                       IF

                         {}

                         { PUSH string "WrongCondition: sp.sender == self.data.administrator" ;

                           FAILWITH } ;

                       DUP ;

                       CAR ;

                       NIL operation ;

                       SWAP ;

                       ITER { DIG 3 ;

                              DUP ;

                              DUG 4 ;

                              { CAR ; CAR ; CAR ; CDR } ;

                              SWAP ;

                              DUP ;

                              DUG 2 ;

                              MEM ;

                              IF

                                { PUSH nat 1 ;

                                  DIG 3 ;

                                  DUP ;

                                  DUG 4 ;

                                  CDR ;

                                  PUSH int 10000000000 ;

                                  ISNAT ;

                                  { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                                  DIG 6 ;

                                  DUP ;

                                  DUG 7 ;

                                  { CAR ; CAR ; CDR ; CAR } ;

                                  ISNAT ;

                                  { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                                  MUL ;

                                  EDIV ;

                                  { IF_NONE

                                      { PUSH string "division by zero" ; FAILWITH }

                                      { CAR } } ;

                                  ADD ;

                                  PUSH int 10000000000 ;

                                  ISNAT ;

                                  { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                                  DIG 5 ;

                                  DUP ;

                                  DUG 6 ;

                                  { CAR ; CAR ; CAR ; CDR } ;

                                  DIG 3 ;

                                  DUP ;

                                  DUG 4 ;

                                  GET ;

                                  { IF_NONE

                                      { PUSH string "Get-item:136" ; FAILWITH }

                                      {} } ;

                                  CAR ;

                                  ISNAT ;

                                  { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                                  MUL ;

                                  COMPARE ;

                                  GT }

                                { PUSH bool False } ;

                              IF

                                { SWAP ;

                                  DUP ;

                                  DUG 2 ;

                                  SWAP ;

                                  DUP ;

                                  DUG 2 ;

                                  CONTRACT unit ;

                                  { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                                  PUSH mutez 1 ;

                                  PUSH nat 1 ;

                                  DIG 6 ;

                                  DUP ;

                                  DUG 7 ;

                                  CDR ;

                                  PUSH int 10000000000 ;

                                  ISNAT ;

                                  { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                                  DIG 9 ;

                                  DUP ;

                                  DUG 10 ;

                                  { CAR ; CAR ; CDR ; CAR } ;

                                  ISNAT ;

                                  { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                                  MUL ;

                                  EDIV ;

                                  { IF_NONE

                                      { PUSH string "division by zero" ; FAILWITH }

                                      { CAR } } ;

                                  ADD ;

                                  PUSH int 10000000000 ;

                                  ISNAT ;

                                  { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                                  DIG 8 ;

                                  DUP ;

                                  DUG 9 ;

                                  { CAR ; CAR ; CAR ; CDR } ;

                                  DIG 6 ;

                                  DUP ;

                                  DUG 7 ;

                                  GET ;

                                  { IF_NONE

                                      { PUSH string "Get-item:136" ; FAILWITH }

                                      {} } ;

                                  CAR ;

                                  ISNAT ;

                                  { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                                  MUL ;

                                  EDIV ;

                                  { IF_NONE

                                      { PUSH string "division by zero" ; FAILWITH }

                                      { CAR } } ;

                                  MUL ;

                                  PUSH unit Unit ;

                                  TRANSFER_TOKENS ;

                                  CONS ;

                                  DUG 2 ;

                                  SWAP ;

                                  DROP }

                                {} ;

                              DROP } ;

                       SWAP ;

                       DROP }

                     { IF_LEFT

                         { DUP ;

                           NIL operation ;

                           SWAP ;

                           CONTRACT address ;

                           { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                           PUSH mutez 0 ;

                           DIG 4 ;

                           DUP ;

                           DUG 5 ;

                           { CAR ; CAR ; CAR ; CAR } ;

                           TRANSFER_TOKENS ;

                           CONS ;

                           SWAP ;

                           DROP }

                         { SWAP ;

                           DUP ;

                           DUG 2 ;

                           { CAR ; CAR ; CAR ; CDR } ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           CAR ;

                           MEM ;

                           IF

                             { DUP ;

                               CDR ;

                               NIL operation ;

                               SWAP ;

                               CONTRACT nat ;

                               { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                               PUSH mutez 0 ;

                               DIG 4 ;

                               DUP ;

                               DUG 5 ;

                               { CAR ; CAR ; CAR ; CDR } ;

                               DIG 4 ;

                               DUP ;

                               DUG 5 ;

                               CAR ;

                               GET ;

                               { IF_NONE { PUSH string "Get-item:154" ; FAILWITH } {} } ;

                               CAR ;

                               ISNAT ;

                               { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                               TRANSFER_TOKENS ;

                               CONS }

                             { DUP ;

                               CDR ;

                               NIL operation ;

                               SWAP ;

                               CONTRACT nat ;

                               { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                               PUSH mutez 0 ;

                               PUSH int 0 ;

                               ISNAT ;

                               { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                               TRANSFER_TOKENS ;

                               CONS } ;

                           SWAP ;

                           DROP } } } }

             { IF_LEFT

                 { IF_LEFT

                     { DUP ;

                       NIL operation ;

                       SWAP ;

                       CONTRACT nat ;

                       { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                       PUSH mutez 0 ;

                       DIG 4 ;

                       DUP ;

                       DUG 5 ;

                       { CAR ; CAR ; CDR ; CAR } ;

                       ISNAT ;

                       { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                       TRANSFER_TOKENS ;

                       CONS ;

                       SWAP ;

                       DROP }

                     { IF_LEFT

                         { DUP ;

                           NIL operation ;

                           SWAP ;

                           CONTRACT nat ;

                           { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                           PUSH mutez 0 ;

                           DIG 4 ;

                           DUP ;

                           DUG 5 ;

                           { CAR ; CDR ; CAR ; CAR } ;

                           ISNAT ;

                           { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                           TRANSFER_TOKENS ;

                           CONS ;

                           SWAP ;

                           DROP }

                         { DUP ;

                           NIL operation ;

                           SWAP ;

                           CONTRACT address ;

                           { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                           PUSH mutez 0 ;

                           DIG 4 ;

                           DUP ;

                           DUG 5 ;

                           { CDR ; CAR ; CAR ; CDR } ;

                           TRANSFER_TOKENS ;

                           CONS ;

                           SWAP ;

                           DROP } } }

                 { IF_LEFT

                     { IF_LEFT

                         { DUP ;

                           NIL operation ;

                           SWAP ;

                           CONTRACT nat ;

                           { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                           PUSH mutez 0 ;

                           DIG 4 ;

                           DUP ;

                           DUG 5 ;

                           { CDR ; CAR ; CAR ; CAR } ;

                           ISNAT ;

                           { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                           TRANSFER_TOKENS ;

                           CONS ;

                           SWAP ;

                           DROP }

                         { SWAP ;

                           DUP ;

                           DUG 2 ;

                           { CDR ; CAR ; CDR ; CAR } ;

                           IF

                             { DUP ;

                               NIL operation ;

                               SWAP ;

                               CONTRACT nat ;

                               { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                               PUSH mutez 0 ;

                               PUSH nat 1 ;

                               TRANSFER_TOKENS ;

                               CONS }

                             { DUP ;

                               NIL operation ;

                               SWAP ;

                               CONTRACT nat ;

                               { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                               PUSH mutez 0 ;

                               PUSH nat 0 ;

                               TRANSFER_TOKENS ;

                               CONS } ;

                           SWAP ;

                           DROP } }

                     { IF_LEFT

                         { DUP ;

                           NIL operation ;

                           SWAP ;

                           CONTRACT nat ;

                           { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                           PUSH mutez 0 ;

                           DIG 4 ;

                           DUP ;

                           DUG 5 ;

                           { CDR ; CAR ; CDR ; CDR } ;

                           ISNAT ;

                           { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                           TRANSFER_TOKENS ;

                           CONS ;

                           SWAP ;

                           DROP }

                         { DUP ;

                           NIL operation ;

                           SWAP ;

                           CONTRACT nat ;

                           { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                           PUSH mutez 0 ;

                           DIG 4 ;

                           DUP ;

                           DUG 5 ;

                           { CDR ; CDR ; CAR ; CAR } ;

                           ISNAT ;

                           { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                           TRANSFER_TOKENS ;

                           CONS ;

                           SWAP ;

                           DROP } } } } }

         { IF_LEFT

             { IF_LEFT

                 { IF_LEFT

                     { SWAP ;

                       DUP ;

                       DUG 2 ;

                       { CDR ; CDR ; CDR ; CDR } ;

                       IF

                         { DUP ;

                           NIL operation ;

                           SWAP ;

                           CONTRACT nat ;

                           { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                           PUSH mutez 0 ;

                           PUSH nat 1 ;

                           TRANSFER_TOKENS ;

                           CONS }

                         { DUP ;

                           NIL operation ;

                           SWAP ;

                           CONTRACT nat ;

                           { IF_NONE { PUSH unit Unit ; FAILWITH } {} } ;

                           PUSH mutez 0 ;

                           PUSH nat 0 ;

                           TRANSFER_TOKENS ;

                           CONS } ;

                       SWAP ;

                       DROP }

                     { IF_LEFT

                         { SWAP ;

                           DUP ;

                           DUG 2 ;

                           { CAR ; CAR ; CAR ; CAR } ;

                           SENDER ;

                           COMPARE ;

                           EQ ;

                           IF

                             {}

                             { PUSH string "WrongCondition: sp.sender == self.data.administrator" ;

                               FAILWITH } ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;