{ parameter (or

              (or

                (or

                  (or (pair %approve (address %spender) (nat %value))

                      (pair %getAllowance

                        (pair %request (address %owner) (address %spender))

                        (contract %callback nat)))

                  (or (pair %getBalance (address %owner) (contract %callback nat))

                      (pair %getTotalSupply (unit %request) (contract %callback nat))))

                (or

                  (or (nat %setTransformPrice)

                      (pair %stake (nat %amount) (nat %duration)))

                  (or (pair %transfer (address %from) (address %to) (nat %value))

                      (address %transform))))

              (or (timestamp %unstake) (mutez %withdraw))) ;

  storage (pair

            (pair

              (pair

                (pair

                  (big_map %allowances (pair (address %owner) (address %spender)) nat)

                  (nat %currentUPPerTez))

                (nat %doubling)

                (timestamp %lastDoubledDate))

              (pair (nat %maxDays) (nat %minDays))

              (nat %stakeTooLate)

              (big_map %stakes address

                               (map timestamp

                                    (pair (pair (nat %amount) (nat %duration))

                                          (timestamp %normalizedStarted)))))

            (pair

              (pair (timestamp %startDate)

                    (big_map %timeline timestamp

                                       (pair (nat %upStaked) (nat %uptimeStaked))))

              (big_map %token_metadata nat

                                       (pair (nat %token_id)

                                             (map %token_info string bytes)))

              (big_map %tokens address nat))

            (pair (nat %total_supply) (nat %transformDurationDays))

            (address %withdraw)) ;

  code { SENDER ;

         LAMBDA

           (pair address

                 (pair nat

                       (pair

                         (pair (pair (big_map (pair address address) nat) nat) nat

                               timestamp)

                         (pair nat nat)

                         nat

                         (big_map address

                                  (map timestamp (pair (pair nat nat) timestamp))))

                       (pair (pair timestamp (big_map timestamp (pair nat nat)))

                             (big_map nat (pair nat (map string bytes)))

                             (big_map address nat))

                       (pair nat nat)

                       address))

           nat

           { UNPAIR ;

             SWAP ;

             UNPAIR ;

             SWAP ;

             CDR ;

             CAR ;

             CDR ;

             CDR ;

             DIG 2 ;

             GET ;

             IF_NONE { PUSH nat 0 } {} ;

             SUB ;

             ISNAT ;

             IF_NONE { PUSH string "Not enough UP" ; FAILWITH } {} } ;

         DUP 2 ;

         APPLY ;

         LAMBDA

           (pair

             (pair (pair (pair (big_map (pair address address) nat) nat) nat timestamp)

                   (pair nat nat)

                   nat

                   (big_map address (map timestamp (pair (pair nat nat) timestamp))))

             (pair (pair timestamp (big_map timestamp (pair nat nat)))

                   (big_map nat (pair nat (map string bytes)))

                   (big_map address nat))

             (pair nat nat)

             address)

           timestamp

           { PUSH int 86400 ;

             PUSH int 86400 ;

             DUP 3 ;

             CDR ;

             CAR ;

             CAR ;

             CAR ;

             NOW ;

             SUB ;

             EDIV ;

             IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;

             CAR ;

             MUL ;

             SWAP ;

             CDR ;

             CAR ;

             CAR ;

             CAR ;

             ADD } ;

         LAMBDA

           (pair address

                 (pair timestamp

                       (pair

                         (pair (pair (big_map (pair address address) nat) nat) nat

                               timestamp)

                         (pair nat nat)

                         nat

                         (big_map address

                                  (map timestamp (pair (pair nat nat) timestamp))))

                       (pair (pair timestamp (big_map timestamp (pair nat nat)))

                             (big_map nat (pair nat (map string bytes)))

                             (big_map address nat))

                       (pair nat nat)

                       address))

           (pair (pair nat nat) timestamp)

           { UNPAIR ;

             SWAP ;

             UNPAIR ;

             SWAP ;

             CAR ;

             CDR ;

             CDR ;

             CDR ;

             DIG 2 ;

             GET ;

             IF_NONE { EMPTY_MAP timestamp (pair (pair nat nat) timestamp) } {} ;

             SWAP ;

             GET ;

             IF_NONE { PUSH timestamp 0 ; PUSH nat 0 ; PUSH nat 0 ; PAIR ; PAIR } {} } ;

         DUP 4 ;

         APPLY ;

         LAMBDA

           (pair address

                 (pair

                   (pair

                     (pair (pair (big_map (pair address address) nat) nat) nat timestamp)

                     (pair nat nat)

                     nat

                     (big_map address (map timestamp (pair (pair nat nat) timestamp))))

                   (pair (pair timestamp (big_map timestamp (pair nat nat)))

                         (big_map nat (pair nat (map string bytes)))

                         (big_map address nat))

                   (pair nat nat)

                   address))

           (map timestamp (pair (pair nat nat) timestamp))

           { UNPAIR ;

             SWAP ;

             CAR ;

             CDR ;

             CDR ;

             CDR ;

             SWAP ;

             GET ;

             IF_NONE { EMPTY_MAP timestamp (pair (pair nat nat) timestamp) } {} } ;

         DUP 5 ;

         APPLY ;

         LAMBDA

           (pair address

                 (pair nat

                       (pair

                         (pair (pair (big_map (pair address address) nat) nat) nat

                               timestamp)

                         (pair nat nat)

                         nat

                         (big_map address

                                  (map timestamp (pair (pair nat nat) timestamp))))

                       (pair (pair timestamp (big_map timestamp (pair nat nat)))

                             (big_map nat (pair nat (map string bytes)))

                             (big_map address nat))

                       (pair nat nat)

                       address))

           (big_map address nat)

           { UNPAIR ; SWAP ; UNPAIR ; SWAP ; CDR ; CAR ; CDR ; CDR ; SWAP ; SOME ; DIG 2 ; UPDATE } ;

         DUP 6 ;

         APPLY ;

         LAMBDA

           (pair (pair address nat)

                 (pair

                   (pair (pair (big_map (pair address address) nat) nat) nat timestamp)

                   (pair nat nat)

                   nat

                   (big_map address (map timestamp (pair (pair nat nat) timestamp))))

                 (pair (pair timestamp (big_map timestamp (pair nat nat)))

                       (big_map nat (pair nat (map string bytes)))

                       (big_map address nat))

                 (pair nat nat)

                 address)

           (big_map address nat)

           { UNPAIR ;

             UNPAIR ;

             SWAP ;

             DUP 3 ;

             CDR ;

             CAR ;

             CDR ;

             CDR ;

             DUP 3 ;

             GET ;

             IF_NONE { PUSH nat 0 } {} ;

             ADD ;

             DIG 2 ;

             CDR ;

             CAR ;

             CDR ;

             CDR ;

             SWAP ;

             SOME ;

             DIG 2 ;

             UPDATE } ;

         LAMBDA

           (pair nat nat)

           nat

           { UNPAIR ;

             PUSH nat 100 ;

             DIG 2 ;

             DUP 3 ;

             MUL ;

             EDIV ;

             IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;

             CAR ;

             ADD } ;

         DIG 8 ;

         UNPAIR ;

         IF_LEFT

           { IF_LEFT

               { DIG 2 ;

                 DIG 3 ;

                 DIG 4 ;

                 DIG 5 ;

                 DIG 6 ;

                 DIG 7 ;

                 DIG 8 ;

                 DIG 9 ;

                 DROP 8 ;

                 IF_LEFT

                   { IF_LEFT

                       { DUP 2 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CAR ;

                         DUP 2 ;

                         CAR ;

                         SENDER ;

                         PAIR ;

                         PUSH nat 0 ;

                         DUP 4 ;

                         CDR ;

                         COMPARE ;

                         GT ;

                         PUSH nat 0 ;

                         DUP 4 ;

                         DUP 4 ;

                         GET ;

                         IF_NONE { PUSH nat 0 } {} ;

                         COMPARE ;

                         GT ;

                         AND ;

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

                         DUP 4 ;

                         CDR ;

                         DUP 5 ;

                         CAR ;

                         CDR ;

                         DUP 6 ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DIG 6 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DIG 6 ;

                         CDR ;

                         DIG 6 ;

                         PUSH nat 0 ;

                         DUP 3 ;

                         COMPARE ;

                         EQ ;

                         IF { SWAP ; DROP ; NONE nat } { SWAP ; SOME } ;

                         DIG 6 ;

                         UPDATE ;

                         PAIR ;

                         PAIR ;

                         PAIR ;

                         PAIR ;

                         NIL operation }

                       { DUP 2 ;

                         NIL operation ;

                         DUP 3 ;

                         CDR ;

                         PUSH mutez 0 ;

                         DIG 5 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CAR ;

                         DIG 5 ;

                         CAR ;

                         GET ;

                         IF_NONE { PUSH nat 0 } {} ;

                         TRANSFER_TOKENS ;

                         CONS } }

                   { IF_LEFT

                       { DUP 2 ;

                         NIL operation ;

                         DUP 3 ;

                         CDR ;

                         PUSH mutez 0 ;

                         DIG 5 ;

                         CDR ;

                         CAR ;

                         CDR ;

                         CDR ;

                         DIG 5 ;

                         CAR ;

                         GET ;

                         IF_NONE { PUSH nat 0 } {} ;

                         TRANSFER_TOKENS }

                       { DUP 2 ;

                         NIL operation ;

                         DIG 2 ;

                         CDR ;

                         PUSH mutez 0 ;

                         DIG 4 ;

                         CDR ;

                         CDR ;

                         CAR ;

                         CAR ;

                         TRANSFER_TOKENS } ;

                     CONS } }

               { IF_LEFT

                   { DIG 3 ;

                     DROP ;

                     IF_LEFT

                       { DIG 2 ;

                         DIG 3 ;

                         DIG 4 ;

                         DIG 5 ;

                         DIG 6 ;

                         DIG 7 ;

                         DROP 6 ;

                         DIG 2 ;

                         DUP 3 ;

                         CDR ;

                         CDR ;

                         CDR ;

                         COMPARE ;

                         NEQ ;

                         IF { PUSH string "You cant set price" ; FAILWITH } {} ;

                         DUP 2 ;

                         CDR ;

                         DUP 3 ;

                         CAR ;

                         CDR ;

                         DUP 4 ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DIG 3 ;

                         DIG 4 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CAR ;

                         PAIR }

                       { DUP 2 ;

                         DUP 2 ;

                         CAR ;

                         PAIR ;

                         DIG 8 ;

                         SWAP ;

                         EXEC ;

                         DUP 3 ;

                         CAR ;

                         CDR ;

                         CAR ;

                         CDR ;

                         DUP 3 ;

                         CDR ;

                         COMPARE ;

                         LT ;

                         IF { PUSH string "Too short time period" ; FAILWITH } {} ;

                         DUP 3 ;

                         CAR ;

                         CDR ;

                         CAR ;

                         CAR ;

                         DUP 3 ;

                         CDR ;

                         COMPARE ;

                         GT ;

                         IF { PUSH string "Too long time period" ; FAILWITH } {} ;

                         DUP 3 ;

                         DUP 9 ;

                         SWAP ;

                         EXEC ;

                         NOW ;

                         DUP 5 ;

                         DUP 2 ;

                         PAIR ;

                         DIG 9 ;

                         SWAP ;

                         EXEC ;

                         PUSH nat 0 ;

                         SWAP ;

                         CAR ;

                         CDR ;

                         COMPARE ;

                         NEQ ;

                         IF { PUSH string "Please wait a few seconds" ; FAILWITH } {} ;

                         DUP 5 ;

                         DIG 3 ;

                         PAIR ;

                         DIG 6 ;

                         SWAP ;

                         EXEC ;

                         PUSH int 86400 ;

                         DUP 4 ;

                         ADD ;

                         DUP 6 ;

                         DIG 8 ;

                         SWAP ;

                         EXEC ;

                         PUSH nat 1 ;

                         DUP 8 ;

                         CDR ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DUP 8 ;

                         CAR ;

                         PAIR ;

                         DUP 8 ;

                         CDR ;

                         DUP 5 ;

                         PAIR ;

                         PAIR ;

                         PAIR ;

                         LEFT (big_map timestamp (pair nat nat)) ;

                         LOOP_LEFT { UNPAIR ;

                                     UNPAIR ;

                                     UNPAIR ;

                                     DIG 2 ;

                                     UNPAIR ;

                                     DUP 4 ;

                                     DUP 6 ;

                                     COMPARE ;

                                     GT ;

                                     IF

                                       { DIG 2 ;

                                         DIG 3 ;

                                         DIG 4 ;

                                         DROP 4 ;

                                         RIGHT (pair

                                                 (pair (pair timestamp nat) nat

                                                       (big_map timestamp (pair nat nat)))

                                                 nat) }

                                       { DUP 2 ;

                                         DUP 4 ;

                                         GET ;

                                         IF_NONE { PUSH nat 0 ; PUSH nat 0 ; PAIR } {} ;

                                         DUP 6 ;

                                         DUP 3 ;

                                         PAIR ;

                                         DUP 15 ;

                                         SWAP ;

                                         EXEC ;

                                         DUP 2 ;

                                         CDR ;

                                         ADD ;

                                         DUP 3 ;

                                         DIG 2 ;

                                         CAR ;

                                         ADD ;

                                         PAIR ;

                                         PUSH int 86400 ;

                                         DUP 5 ;

                                         ADD ;

                                         PUSH nat 1 ;

                                         DIG 7 ;

                                         ADD ;

                                         DIG 4 ;

                                         DIG 3 ;

                                         SOME ;

                                         DIG 5 ;

                                         UPDATE ;

                                         DIG 3 ;

                                         PAIR ;

                                         DIG 3 ;

                                         DIG 3 ;

                                         PAIR ;

                                         PAIR ;

                                         PAIR ;

                                         LEFT (big_map timestamp (pair nat nat)) } } ;

                         DIG 8 ;

                         DROP ;

                         DUP 8 ;

                         DIG 9 ;

                         SWAP ;

                         EXEC ;

                         PUSH int 86400 ;

                         DUP 10 ;

                         CAR ;

                         CAR ;

                         CDR ;

                         CAR ;

                         MUL ;

                         DUP 10 ;

                         CAR ;

                         CAR ;

                         CDR ;

                         CDR ;

                         DIG 2 ;

                         SUB ;

                         COMPARE ;

                         GT ;

                         IF

                           { PUSH nat 2 ; DUP 9 ; CAR ; CDR ; CAR ; CDR ; MUL }

                           { DUP 8 ; CAR ; CDR ; CAR ; CDR } ;

                         DUP 9 ;

                         CDR ;

                         CDR ;

                         DUP 10 ;

                         CDR ;

                         CAR ;

                         CDR ;

                         DIG 3 ;

                         DUP 11 ;

                         CDR ;

                         CAR ;

                         CAR ;

                         CAR ;

                         PAIR ;

                         PAIR ;

                         PAIR ;

                         DUP 9 ;

                         CAR ;

                         PAIR ;

                         DUP ;

                         CDR ;

                         DUP 10 ;

                         CAR ;

                         CDR ;

                         CDR ;

                         CDR ;

                         DIG 4 ;

                         DIG 5 ;

                         DIG 9 ;

                         PAIR ;

                         SOME ;

                         DIG 7 ;

                         UPDATE ;

                         SOME ;

                         DIG 8 ;

                         UPDATE ;

                         DUP 3 ;

                         CAR ;

                         CDR ;

                         CDR ;

                         CAR ;

                         PAIR ;

                         DUP 3 ;

                         CAR ;

                         CDR ;

                         CAR ;

                         PAIR ;

                         DIG 2 ;

                         CAR ;

                         CAR ;

                         PAIR ;

                         PAIR ;

                         DUP ;

                         CDR ;

                         CDR ;

                         DIG 3 ;

                         DUP 3 ;

                         CDR ;

                         CAR ;

                         CDR ;

                         CAR ;

                         PAIR ;

                         DUP 3 ;

                         CDR ;

                         CAR ;

                         CAR ;

                         PAIR ;

                         PAIR ;

                         SWAP ;

                         CAR ;

                         PAIR ;

                         DUP ;

                         CDR ;

                         DUP 2 ;

                         CAR ;

                         CDR ;

                         CDR ;

                         DUP 4 ;

                         DUP 4 ;

                         CAR ;

                         CDR ;

                         CAR ;

                         CAR ;

                         PAIR ;

                         PAIR ;

                         DIG 2 ;

                         CAR ;

                         CAR ;

                         PAIR ;

                         PAIR ;

                         DUP ;

                         CDR ;

                         DUP 2 ;

                         CAR ;

                         CDR ;

                         DUP 6 ;

                         CAR ;

                         CDR ;

                         CAR ;

                         CDR ;

                         DIG 4 ;

                         COMPARE ;

                         GT ;

                         IF

                           { DIG 4 ; DROP ; DIG 3 }

                           { DIG 3 ; DROP ; DIG 3 ; CAR ; CAR ; CDR ; CDR } ;

                         DUP 4 ;

                         CAR ;

                         CAR ;

                         CDR ;

                         CAR ;

                         PAIR ;

                         DIG 3 ;

                         CAR ;

                         CAR ;

                         CAR } ;

                     PAIR ;

                     PAIR }

                   { DIG 2 ;

                     DIG 4 ;

                     DIG 5 ;

                     DIG 6 ;

                     DIG 8 ;

                     DROP 5 ;

                     IF_LEFT

                       { DIG 2 ;

                         DIG 3 ;

                         DIG 4 ;

                         DROP 3 ;

                         DUP 2 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CAR ;

                         DUP 3 ;

                         CDR ;

                         CAR ;

                         CDR ;

                         CDR ;

                         DUP 3 ;

                         CAR ;

                         SENDER ;

                         COMPARE ;

                         EQ ;

                         IF

                           { SWAP }

                           { SENDER ;

                             DUP 4 ;

                             CAR ;

                             PAIR ;

                             DUP 4 ;

                             GET 4 ;

                             DUP 4 ;

                             DUP 3 ;

                             GET ;

                             IF_NONE { PUSH nat 0 } {} ;

                             SUB ;

                             ISNAT ;

                             IF_NONE

                               { PUSH string "NotEnoughAllowance" ; FAILWITH }

                               {} ;

                             DIG 3 ;

                             PUSH nat 0 ;

                             DUP 3 ;

                             COMPARE ;

                             EQ ;

                             IF { SWAP ; DROP ; NONE nat } { SWAP ; SOME } ;

                             DIG 2 ;

                             UPDATE } ;

                         DUP 3 ;

                         GET 4 ;

                         DUP 3 ;

                         DUP 5 ;

                         CAR ;

                         GET ;

                         IF_NONE { PUSH nat 0 } {} ;

                         SUB ;

                         ISNAT ;

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

                         DIG 2 ;

                         PUSH nat 0 ;

                         DUP 3 ;

                         COMPARE ;

                         EQ ;

                         IF { SWAP ; DROP ; NONE nat } { SWAP ; SOME } ;

                         DUP 4 ;

                         CAR ;

                         UPDATE ;

                         DUP 3 ;

                         GET 4 ;

                         DUP 2 ;

                         DUP 5 ;

                         GET 3 ;

                         GET ;

                         IF_NONE { PUSH nat 0 } {} ;

                         ADD ;

                         DUP 5 ;

                         CDR ;

                         CDR ;

                         DIG 2 ;

                         PUSH nat 0 ;

                         DUP 4 ;

                         COMPARE ;

                         EQ ;

                         IF { DIG 2 ; DROP ; NONE nat } { DIG 2 ; SOME } ;

                         DIG 4 ;

                         GET 3 ;

                         UPDATE ;

                         DUP 4 ;

                         CDR ;

                         CAR ;

                         CDR ;

                         CAR ;

                         PAIR ;

                         DUP 4 ;

                         CDR ;

                         CAR ;

                         CAR ;

                         PAIR ;

                         PAIR ;

                         DIG 2 ;

                         CAR ;

                         PAIR ;

                         DUP ;

                         CDR ;

                         DUP 2 ;

                         CAR ;

                         CDR ;

                         DUP 3 ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DIG 3 ;

                         CAR ;

                         CAR ;

                         CAR ;

                         CDR ;

                         DIG 4 ;

                         PAIR ;

                         PAIR ;

                         PAIR }

                       { PUSH mutez 1000000 ;

                         AMOUNT ;

                         EDIV ;

                         IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;

                         CAR ;

                         DUP 3 ;

                         DIG 5 ;

                         SWAP ;

                         EXEC ;

                         PUSH int 86400 ;

                         DUP 5 ;

                         CDR ;

                         CDR ;

                         CAR ;

                         CDR ;

                         MUL ;

                         DUP 5 ;

                         CDR ;

                         CAR ;

                         CAR ;

                         CAR ;

                         DIG 2 ;

                         SUB ;

                         COMPARE ;

                         GE ;

                         IF { PUSH string "Transformation phase over" ; FAILWITH } {} ;

                         PUSH nat 0 ;

                         DUP 2 ;

                         COMPARE ;

                         LE ;

                         IF { PUSH string "Must send some tez" ; FAILWITH } {} ;