parameter (or

            (or

              (or (lambda %execute unit (list operation))

                  (list %import_stakes (pair (address %updater)

                                            (pair (address %owner) (nat %amount)))))

              (or

                (pair %remove_administrator (address %administrator_to_remove)

                                            (nat %token_id))

                (pair %set_administrator (address %administrator_to_set) (nat %token_id))))

            (or

              (or (pair %set_fixed_stake (address %address) (nat %ratio))

                  (pair %set_stake_factor (address %address) (nat %factor)))

              (or (list %update_fixed_stakes address)

                  (pair %update_stake (address %address) (nat %amount)))));

storage (pair

          (pair (big_map %administrators (pair (address %owner) (nat %token_id)) unit)

                (pair (big_map %fixed_stakes address nat)

                      (big_map %global_stakes address nat)))

          (pair

            (pair (address %governance_token_contract)

                  (big_map %local_stakes (pair (address %owner) (address %engine))

                                         (pair (nat %stake) (nat %introducer_stake))))

            (pair (big_map %stake_factors address nat) (nat %total_stake))));

code { LAMBDA

         (pair (pair address nat)

               (pair (list operation)

                     (pair

                       (pair (big_map (pair address nat) unit)

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

                       (pair

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

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

         (pair unit

               (pair (list operation)

                     (pair

                       (pair (big_map (pair address nat) unit)

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

                       (pair

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

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

         { UNPAIR 3 ;

           SWAP ;

           DUP 3 ;

           GET 3 ;

           CAR ;

           CONTRACT %update_stake (pair (address %address) (nat %amount)) ;

           IF_NONE { PUSH int 141 ; FAILWITH } {} ;

           PUSH mutez 0 ;

           DIG 3 ;

           TRANSFER_TOKENS ;

           CONS ;

           UNIT ;

           PAIR 3 } ;

       SWAP ;

       LAMBDA

         (pair nat

               (pair (list operation)

                     (pair

                       (pair (big_map (pair address nat) unit)

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

                       (pair

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

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

         (pair unit

               (pair (list operation)

                     (pair

                       (pair (big_map (pair address nat) unit)

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

                       (pair

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

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

         { UNPAIR 3 ;

           SWAP ;

           DUP 3 ;

           CAR ;

           CAR ;

           DIG 2 ;

           SENDER ;

           PAIR ;

           MEM ;

           IF {} { PUSH int 401 ; FAILWITH } ;

           UNIT ;

           PAIR 3 } ;

       SWAP ;

       UNPAIR ;

       IF_LEFT

         { IF_LEFT

             { IF_LEFT

                 { AMOUNT ;

                   PUSH mutez 0 ;

                   COMPARE ;

                   EQ ;

                   IF {} { AMOUNT ; FAILWITH } ;

                   NIL operation ;

                   DUP 4 ;

                   PUSH nat 0 ;

                   SWAP ;

                   DIG 4 ;

                   DIG 3 ;

                   DIG 3 ;

                   PAIR 3 ;

                   EXEC ;

                   UNPAIR 3 ;

                   DIG 5 ;

                   DIG 5 ;

                   DIG 4 ;

                   DIG 5 ;

                   DIG 5 ;

                   DIG 5 ;

                   DUP 3 ;

                   UNIT ;

                   EXEC ;

                   NIL operation ;

                   SWAP ;

                   ITER { CONS } ;

                   ITER { DIG 2 ; SWAP ; CONS ; SWAP } ;

                   DROP ;

                   SWAP ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP }

                 { AMOUNT ;

                   PUSH mutez 0 ;

                   COMPARE ;

                   EQ ;

                   IF {} { AMOUNT ; FAILWITH } ;

                   NIL operation ;

                   DUP 4 ;

                   PUSH nat 0 ;

                   SWAP ;

                   DIG 4 ;

                   DIG 3 ;

                   DIG 3 ;

                   PAIR 3 ;

                   EXEC ;

                   UNPAIR 3 ;

                   DIG 5 ;

                   DIG 5 ;

                   DIG 4 ;

                   DIG 5 ;

                   DIG 5 ;

                   DIG 5 ;

                   DUP 3 ;

                   ITER { DUP 5 ;

                          CAR ;

                          GET 4 ;

                          SWAP ;

                          DUP ;

                          DUG 2 ;

                          GET 3 ;

                          MEM ;

                          IF

                            { DROP }

                            { DIG 4 ;

                              UNPAIR ;

                              SWAP ;

                              UNPAIR ;

                              UNPAIR ;

                              SWAP ;

                              PUSH nat 0 ;

                              DUP 6 ;

                              GET 4 ;

                              PAIR ;

                              SOME ;

                              DIG 5 ;

                              DUP ;

                              CAR ;

                              SWAP ;

                              DUP ;

                              DUG 7 ;

                              GET 3 ;

                              PAIR ;

                              UPDATE ;

                              SWAP ;

                              PAIR ;

                              PAIR ;

                              SWAP ;

                              UNPAIR ;

                              SWAP ;

                              UNPAIR ;

                              SWAP ;

                              DUP 5 ;

                              GET 4 ;

                              SOME ;

                              DUP 6 ;

                              GET 3 ;

                              UPDATE ;

                              SWAP ;

                              PAIR ;

                              SWAP ;

                              PAIR ;

                              PAIR ;

                              DUP ;

                              GET 6 ;

                              DIG 2 ;

                              GET 4 ;

                              ADD ;

                              UPDATE 6 ;

                              DUG 3 } } ;

                   DROP ;

                   SWAP ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP } }

             { IF_LEFT

                 { DIG 3 ;

                   DROP ;

                   AMOUNT ;

                   PUSH mutez 0 ;

                   COMPARE ;

                   EQ ;

                   IF {} { AMOUNT ; FAILWITH } ;

                   NIL operation ;

                   DIG 3 ;

                   DUP 3 ;

                   CDR ;

                   SWAP ;

                   DIG 4 ;

                   DIG 3 ;

                   DIG 3 ;

                   PAIR 3 ;

                   EXEC ;

                   CDR ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   UNPAIR ;

                   NONE unit ;

                   DIG 5 ;

                   UPDATE ;

                   PAIR ;

                   PAIR ;

                   SWAP }

                 { DIG 3 ;

                   DROP ;

                   AMOUNT ;

                   PUSH mutez 0 ;

                   COMPARE ;

                   EQ ;

                   IF {} { AMOUNT ; FAILWITH } ;

                   NIL operation ;

                   DIG 3 ;

                   DUP 3 ;

                   CDR ;

                   SWAP ;

                   DIG 4 ;

                   DIG 3 ;

                   DIG 3 ;

                   PAIR 3 ;

                   EXEC ;

                   CDR ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   UNPAIR ;

                   PUSH (option unit) (Some Unit) ;

                   DIG 5 ;

                   UPDATE ;

                   PAIR ;

                   PAIR ;

                   SWAP } } }

         { IF_LEFT

             { IF_LEFT

                 { DIG 3 ;

                   DROP ;

                   AMOUNT ;

                   PUSH mutez 0 ;

                   COMPARE ;

                   EQ ;

                   IF {} { AMOUNT ; FAILWITH } ;

                   NIL operation ;

                   DIG 3 ;

                   PUSH nat 0 ;

                   SWAP ;

                   DIG 4 ;

                   DIG 3 ;

                   DIG 3 ;

                   PAIR 3 ;

                   EXEC ;

                   CDR ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   UNPAIR ;

                   SWAP ;

                   UNPAIR ;

                   DUP 6 ;

                   CDR ;

                   SOME ;

                   DIG 6 ;

                   CAR ;

                   UPDATE ;

                   PAIR ;

                   SWAP ;

                   PAIR ;

                   PAIR ;

                   SWAP }

                 { DIG 3 ;

                   DROP ;

                   AMOUNT ;

                   PUSH mutez 0 ;

                   COMPARE ;

                   EQ ;

                   IF {} { AMOUNT ; FAILWITH } ;

                   NIL operation ;

                   DIG 3 ;

                   PUSH nat 0 ;

                   SWAP ;

                   DIG 4 ;

                   DIG 3 ;

                   DIG 3 ;

                   PAIR 3 ;

                   EXEC ;

                   CDR ;

                   UNPAIR ;

                   SWAP ;

                   DUP ;

                   GET 5 ;

                   DUP 4 ;

                   CDR ;

                   SOME ;

                   DIG 4 ;

                   CAR ;

                   UPDATE ;

                   UPDATE 5 ;

                   SWAP } }

             { IF_LEFT

                 { AMOUNT ;

                   PUSH mutez 0 ;

                   COMPARE ;

                   EQ ;

                   IF {} { AMOUNT ; FAILWITH } ;

                   DUP ;

                   NIL operation ;

                   SWAP ;

                   ITER { DUP 6 ;

                          PUSH nat 1000000000000 ;

                          DUP 6 ;

                          CAR ;

                          GET 3 ;

                          DUP 4 ;

                          GET ;

                          IF_NONE { PUSH int 277 ; FAILWITH } {} ;

                          DUP 7 ;

                          GET 6 ;

                          MUL ;

                          EDIV ;

                          IF_NONE { PUSH int 276 ; FAILWITH } { CAR } ;

                          DIG 2 ;

                          PAIR ;

                          SWAP ;

                          DIG 4 ;

                          DIG 3 ;

                          DIG 3 ;

                          PAIR 3 ;

                          EXEC ;

                          CDR ;

                          UNPAIR ;

                          DIG 4 ;

                          DIG 4 ;

                          DIG 3 ;

                          DIG 4 ;

                          DIG 4 } ;

                   SWAP ;

                   DROP ;

                   DIG 2 ;

                   DROP ;

                   DIG 2 ;

                   DROP }

                 { AMOUNT ;

                   PUSH mutez 0 ;

                   COMPARE ;

                   EQ ;

                   IF {} { AMOUNT ; FAILWITH } ;

                   NIL operation ;

                   DUP 4 ;

                   PUSH nat 0 ;

                   SWAP ;

                   DIG 4 ;

                   DIG 3 ;

                   DIG 3 ;

                   PAIR 3 ;

                   EXEC ;

                   UNPAIR 3 ;

                   DIG 5 ;

                   DIG 5 ;

                   DIG 4 ;

                   DIG 5 ;

                   DIG 5 ;

                   DIG 5 ;

                   NONE address ;

                   PUSH nat 0 ;

                   PUSH bool False ;

                   SENDER ;

                   DUP 7 ;

                   CAR ;

                   VIEW "vault_context"

                         (option (pair (nat %balance)

                                      (pair (option %introducer address) (nat %minted)))) ;

                   IF_NONE

                     { SENDER ;

                       DUP 7 ;

                       CAR ;

                       VIEW "vault_context"

                             (option (pair (address %address)

                                          (pair (nat %balance)

                                                (pair (option %introducer address)

                                                      (nat %minted))))) ;

                       IF_NONE { PUSH string "Invalid tez vault view" ; FAILWITH } {} ;

                       IF_NONE

                         {}

                         { DROP 4 ;

                           PUSH bool True ;

                           SENDER ;

                           DUP 5 ;

                           CAR ;

                           VIEW "vault_context"

                                 (option (pair (address %address)

                                              (pair (nat %balance)

                                                    (pair (option %introducer address)

                                                          (nat %minted))))) ;

                           IF_NONE

                             { PUSH string "Invalid tez vault view" ; FAILWITH }

                             {} ;

                           IF_NONE { PUSH int 179 ; FAILWITH } {} ;

                           GET 5 ;

                           SWAP ;

                           SENDER ;

                           DUP 6 ;

                           CAR ;

                           VIEW "vault_context"

                                 (option (pair (address %address)

                                              (pair (nat %balance)

                                                    (pair (option %introducer address)

                                                          (nat %minted))))) ;

                           IF_NONE

                             { PUSH string "Invalid tez vault view" ; FAILWITH }

                             {} ;

                           IF_NONE { PUSH int 179 ; FAILWITH } {} ;

                           GET 6 ;

                           SWAP } }

                     { DROP ;

                       SENDER ;

                       DUP 7 ;

                       CAR ;

                       VIEW "vault_context"

                             (option (pair (nat %balance)

                                          (pair (option %introducer address)

                                                (nat %minted)))) ;

                       IF_NONE

                         { PUSH string "Invalid token vault view" ; FAILWITH }

                         {} ;

                       IF_NONE

                         {}

                         { DROP 4 ;

                           PUSH bool True ;

                           SENDER ;

                           DUP 5 ;

                           CAR ;

                           VIEW "vault_context"

                                 (option (pair (nat %balance)

                                              (pair (option %introducer address)

                                                    (nat %minted)))) ;

                           IF_NONE

                             { PUSH string "Invalid token vault view" ; FAILWITH }

                             {} ;

                           IF_NONE { PUSH int 172 ; FAILWITH } {} ;

                           GET 3 ;

                           SWAP ;

                           SENDER ;

                           DUP 6 ;

                           CAR ;

                           VIEW "vault_context"

                                 (option (pair (nat %balance)

                                              (pair (option %introducer address)

                                                    (nat %minted)))) ;

                           IF_NONE

                             { PUSH string "Invalid token vault view" ; FAILWITH }

                             {} ;

                           IF_NONE { PUSH int 172 ; FAILWITH } {} ;

                           GET 4 ;

                           SWAP } } ;

                   DUP ;

                   IF { DUP 6 ; CDR ; DUP 3 ; COMPARE ; EQ } { PUSH bool False } ;

                   IF

                     { SENDER ;

                       DUP 7 ;

                       CAR ;

                       PAIR ;

                       DUP 8 ;

                       GET 3 ;

                       CDR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       GET ;

                       IF_NONE { PUSH (pair nat nat) (Pair 0 0) } {} ;

                       PUSH nat 1000000000000 ;

                       DUP 10 ;

                       GET 5 ;

                       SENDER ;

                       GET ;

                       IF_NONE { PUSH int 197 ; FAILWITH } {} ;

                       DUP 10 ;

                       CDR ;

                       MUL ;

                       EDIV ;

                       IF_NONE { PUSH int 197 ; FAILWITH } { CAR } ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       CAR ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       SUB ;

                       DUP 11 ;

                       CAR ;

                       GET 4 ;

                       DUP 11 ;

                       CAR ;

                       GET ;

                       IF_NONE { PUSH nat 0 } {} ;

                       SWAP ;

                       DUP ;

                       DUG 2 ;

                       SWAP ;

                       INT ;

                       ADD ;

                       ISNAT ;

                       IF_NONE { PUSH int 205 ; FAILWITH } {} ;

                       DUP 12 ;

                       DUP 3 ;

                       DIG 13 ;

                       GET 6 ;

                       INT ;

                       ADD ;

                       ISNAT ;

                       IF_NONE { PUSH int 208 ; FAILWITH } {} ;

                       UPDATE 6 ;

                       DUG 11 ;

                       PUSH nat 0 ;

                       DUP 9 ;

                       IF_NONE

                         {}

                         { DROP 2 ;

                           DUP 8 ;

                           IF_NONE { PUSH int 604 ; FAILWITH } {} ;

                           SENDER ;

                           UNIT ;

                           VIEW "introducer_ratio"

                                 (pair (nat %numerator) (nat %denominator)) ;

                           IF_NONE

                             { PUSH string "Invalid introducer ratio view" ; FAILWITH }

                             {} ;

                           CDR ;

                           SENDER ;

                           UNIT ;

                           VIEW "introducer_ratio"

                                 (pair (nat %numerator) (nat %denominator)) ;

                           IF_NONE

                             { PUSH string "Invalid introducer ratio view" ; FAILWITH }

                             {} ;

                           CAR ;

                           DUP 6 ;

                           MUL ;

                           EDIV ;

                           IF_NONE { PUSH int 227 ; FAILWITH } {} ;

                           CAR ;

                           SWAP ;

                           DUP 14 ;

                           CAR ;

                           GET 4 ;

                           SWAP ;

                           DUP ;

                           DUG 2 ;

                           GET ;

                           IF_NONE { PUSH nat 0 } {} ;

                           DUP 7 ;

                           CDR ;

                           DUP 4 ;

                           SUB ;

                           DUP ;

                           DIG 2 ;

                           INT ;

                           ADD ;

                           ISNAT ;

                           IF_NONE { PUSH int 241 ; FAILWITH } {} ;

                           SWAP ;

                           DUP 16 ;

                           SWAP ;

                           DIG 16 ;

                           GET 6 ;

                           INT ;

                           ADD ;

                           ISNAT ;

                           IF_NONE { PUSH int 244 ; FAILWITH } {} ;

                           UPDATE 6 ;

                           DUG 14 ;

                           DUP ;

                           PUSH nat 0 ;

                           COMPARE ;

                           NEQ ;

                           IF

                             { DIG 14 ;

                               UNPAIR ;

                               UNPAIR ;

                               SWAP ;

                               UNPAIR ;

                               SWAP ;

                               DUP 5 ;

                               SOME ;

                               DUP 7 ;

                               UPDATE ;

                               SWAP ;

                               PAIR ;

                               SWAP ;

                               PAIR ;

                               PAIR ;

                               DUG 14 }

                             { DIG 14 ;

                               UNPAIR ;

                               UNPAIR ;

                               SWAP ;

                               UNPAIR ;

                               SWAP ;

                               NONE nat ;

                               DUP 7 ;

                               UPDATE ;

                               SWAP ;

                               PAIR ;

                               SWAP ;

                               PAIR ;

                               PAIR ;

                               DUG 14 } ;

                           DUP 17 ;

                           SWAP ;

                           DIG 2 ;

                           PAIR ;

                           SWAP ;

                           DIG 14 ;

                           DIG 13 ;

                           DIG 3 ;

                           PAIR 3 ;

                           EXEC ;

                           CDR ;

                           UNPAIR ;

                           DIG 14 ;

                           DIG 14 ;

                           DIG 3 ;

                           DIG 14 ;

                           DIG 4 ;

                           DUG 14 ;

                           DUG 14 ;

                           DUG 14 ;

                           DUG 14 ;

                           DUG 14 } ;

                       PUSH nat 0 ;

                       DUP 3 ;

                       COMPARE ;

                       NEQ ;

                       IF

                         { DIG 12 ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           SWAP ;

                           DUP 6 ;

                           SOME ;

                           DUP 17 ;

                           CAR ;

                           UPDATE ;

                           SWAP ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           DUG 12 }

                         { DIG 12 ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           SWAP ;

                           NONE nat ;

                           DUP 17 ;

                           CAR ;

                           UPDATE ;

                           SWAP ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           DUG 12 } ;

                       PUSH nat 0 ;

                       DUP 5 ;

                       COMPARE ;

                       NEQ ;

                       IF

                         { DIG 2 ;

                           DROP ;

                           DIG 3 ;

                           DROP ;

                           DIG 4 ;

                           DROP ;

                           DIG 4 ;

                           DROP ;

                           DIG 4 ;

                           DROP ;

                           DIG 4 ;

                           DROP ;

                           DIG 7 ;

                           DROP ;

                           DIG 6 ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           DIG 4 ;

                           DIG 6 ;

                           PAIR ;

                           SOME ;

                           DIG 6 ;

                           UPDATE ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           DUG 3 }

                         { DROP ;

                           SWAP ;

                           DROP ;

                           SWAP ;

                           DROP ;

                           SWAP ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 2 ;

                           DROP ;

                           DIG 5 ;

                           DROP ;

                           DIG 4 ;

                           UNPAIR ;

                           SWAP ;

                           UNPAIR ;

                           UNPAIR ;

                           SWAP ;

                           NONE (pair nat nat) ;

                           DIG 6 ;

                           UPDATE ;

                           SWAP ;

                           PAIR ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           DUG 3 } ;

                       DIG 4 ;

                       SWAP ;

                       DIG 3 ;

                       CAR ;

                       PAIR ;

                       SWAP ;

                       DUG 3 ;

                       PAIR 3 ;

                       EXEC ;

                       CDR ;

                       UNPAIR }

                     { DROP 4 ; SWAP ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP } } } } ;

       NIL operation ;

       SWAP ;

       ITER { CONS } ;

       PAIR }