parameter (or

            (or

              (or

                (pair %voteForProposal (nat :proposalId)

                                       (pair (key :votePk) (signature :voteSig)))

                (pair %getBalance (address :owner) (contract nat)))

              (or (pair %getTotalSupply unit (contract nat)) (bytes %fund)))

            (or

              (or

                (or (set %newCouncil key_hash)

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

                (or

                  (pair %newProposal (string :description)

                                     (map :newPolicy string (pair bytes string)))

                  (unit %freeze)))

              (or (pair %withdraw (address :to) (mutez :amount))

                  (lambda :successor %setSuccessor

                    (or

                      (or

                        (pair (nat :proposalId)

                              (pair (key :votePk) (signature :voteSig)))

                        (pair (address :owner) (contract nat)))

                      (or (pair unit (contract nat)) bytes))

                    operation))));

storage (pair

          (pair (pair address (set key_hash))

                (pair (map string (pair bytes string))

                      (pair

                        (list (pair (pair string (map string (pair bytes string))) bytes))

                        (map key_hash nat))))

          (pair (pair nat nat)

                (pair (big_map address nat)

                      (pair bool

                            (option (lambda

                                     (or

                                       (or (pair nat (pair key signature))

                                           (pair address (contract nat)))

                                       (or (pair unit (contract nat)) bytes))

                                     operation))))));

code { CAST (pair

              (or

                (or (or (pair nat (pair key signature)) (pair address (contract nat)))

                    (or (pair unit (contract nat)) bytes))

                (or

                  (or (or (set key_hash) (pair address (pair address nat)))

                      (or (pair string (map string (pair bytes string))) unit))

                  (or (pair address mutez)

                      (lambda

                        (or

                          (or (pair nat (pair key signature))

                              (pair address (contract nat)))

                          (or (pair unit (contract nat)) bytes))

                        operation))))

              (pair

                (pair (pair address (set key_hash))

                      (pair (map string (pair bytes string))

                            (pair

                              (list (pair (pair string (map string (pair bytes string)))

                                         bytes))

                              (map key_hash nat))))

                (pair (pair nat nat)

                      (pair (big_map address nat)

                            (pair bool

                                  (option (lambda

                                           (or

                                             (or (pair nat (pair key signature))

                                                 (pair address (contract nat)))

                                             (or (pair unit (contract nat)) bytes))

                                           operation))))))) ;

       DUP ;

       CAR ;

       DIP { CDR } ;

       IF_LEFT

         { DIP { DUP } ;

           SWAP ;

           CDR ;

           CDR ;

           CDR ;

           CDR ;

           IF_NONE

             { DIP { DUP } ;

               SWAP ;

               CDR ;

               CDR ;

               CDR ;

               CAR ;

               IF

                 { PUSH unit Unit ; PUSH string "ContractFrozen" ; PAIR ; FAILWITH }

                 {} ;

               IF_LEFT

                 { IF_LEFT

                     { DIP { DUP ;

                             CDR ;

                             CAR ;

                             CAR ;

                             DUP ;

                             NOW ;

                             PUSH timestamp "1858-11-17T00:00:00Z" ;

                             SWAP ;

                             SUB ;

                             DIP { PUSH nat 86400 } ;

                             EDIV ;

                             IF_NONE

                               { PUSH string "Internal: extractDate: unexpected (1)" ;

                                 FAILWITH }

                               {} ;

                             CAR ;

                             PUSH nat 678575 ;

                             ADD ;

                             DIP { PUSH nat 146097 } ;

                             EDIV ;

                             IF_NONE

                               { PUSH string "Internal: toOrdinalDate: unexpected (1)" ;

                                 FAILWITH }

                               {} ;

                             DUP ;

                             CAR ;

                             DIP { CDR } ;

                             DIP { DUP ;

                                   DIP { PUSH nat 36524 } ;

                                   EDIV ;

                                   IF_NONE

                                     { PUSH string "Internal: toOrdinalDate: unexpected (2)" ;

                                       FAILWITH }

                                     {} ;

                                   CAR ;

                                   DUP ;

                                   PUSH nat 3 ;

                                   COMPARE ;

                                   GT ;

                                   IF {} { DROP ; PUSH nat 3 } ;

                                   DUP ;

                                   DIP { SWAP } ;

                                   PUSH nat 36524 ;

                                   MUL ;

                                   SWAP ;

                                   SUB ;

                                   DIP { PUSH nat 1461 } ;

                                   EDIV ;

                                   IF_NONE

                                     { PUSH string "Internal: toOrdinalDate: unexpected (3)" ;

                                       FAILWITH }

                                     {} ;

                                   DUP ;

                                   CAR ;

                                   DIP { CDR } ;

                                   SWAP ;

                                   DUP ;

                                   DIP { DIP { PUSH nat 365 } ;

                                         EDIV ;

                                         IF_NONE

                                           { PUSH string "Internal: toOrdinalDate: unexpected (4)" ;

                                             FAILWITH }

                                           {} ;

                                         CAR ;

                                         DUP ;

                                         PUSH nat 3 ;

                                         COMPARE ;

                                         GT ;

                                         IF {} { DROP ; PUSH nat 3 } ;

                                         DUP ;

                                         DIP {} ;

                                         PUSH nat 365 ;

                                         MUL } ;

                                   SUB ;

                                   PUSH nat 1 ;

                                   ADD ;

                                   ISNAT ;

                                   IF_NONE

                                     { PUSH string "Internal: toOrdinalDate: unexpected (5)" ;

                                       FAILWITH }

                                     {} } ;

                             SWAP ;

                             DIP { PUSH nat 400 ;

                                   MUL ;

                                   PUSH nat 1 ;

                                   ADD ;

                                   DIP {} ;

                                   ADD ;

                                   DIP { PUSH nat 4 ; MUL } ;

                                   ADD ;

                                   DIP { PUSH nat 100 ; MUL } ;

                                   ADD } ;

                             SWAP ;

                             DUP ;

                             DIP { DUP ;

                                   DIP { DUP } ;

                                   DIP { PUSH nat 400 } ;

                                   EDIV ;

                                   IF_NONE

                                     { PUSH string "Internal: isLeap: unexpected (1)" ;

                                       FAILWITH }

                                     {} ;

                                   CDR ;

                                   INT ;

                                   EQ ;

                                   SWAP ;

                                   DIP { PUSH nat 100 } ;

                                   EDIV ;

                                   IF_NONE

                                     { PUSH string "Internal: isLeap: unexpected (1)" ;

                                       FAILWITH }

                                     {} ;

                                   CDR ;

                                   INT ;

                                   NEQ ;

                                   OR ;

                                   SWAP ;

                                   DIP { PUSH nat 4 } ;

                                   EDIV ;

                                   IF_NONE

                                     { PUSH string "Internal: isLeap: unexpected (1)" ;

                                       FAILWITH }

                                     {} ;

                                   CDR ;

                                   INT ;

                                   EQ ;

                                   AND ;

                                   PUSH (list nat) { 31 ; 30 ; 31 ; 30 ; 31 ; 31 ; 30 ; 31 ; 30 ; 31 } ;

                                   SWAP ;

                                   IF { PUSH nat 29 } { PUSH nat 28 } ;

                                   CONS ;

                                   PUSH nat 31 ;

                                   CONS ;

                                   DIP { PUSH nat 1 ;

                                         SWAP ;

                                         SUB ;

                                         ISNAT ;

                                         IF_NONE

                                           { PUSH string "Internal: yearDayToMonthAndDay: year day <= 1" ;

                                             FAILWITH }

                                           {} ;

                                         SOME ;

                                         DIP { NONE nat ; PUSH nat 0 } } ;

                                   ITER { SWAP ;

                                          IF_NONE

                                            { DROP ; NONE nat }

                                            { DIP 2 { PUSH nat 1 ; ADD } ;

                                              DUP ;

                                              DIP { SWAP } ;

                                              SUB ;

                                              ISNAT ;

                                              IF_NONE

                                                { SWAP ;

                                                  DIP { DIP { DROP } ; PUSH nat 1 ; ADD ; SOME } ;

                                                  NONE nat }

                                                { DIP { DROP } ; SOME } } } ;

                                   DROP ;

                                   DIP { IF_NONE

                                           { PUSH string "Internal: yearDayToMonthAndDay: year day is greater than number of days in year" ;

                                             FAILWITH }

                                           {} } } ;

                             PUSH nat 2020 ;

                             SWAP ;

                             SUB ;

                             ISNAT ;

                             IF_NONE

                               { PUSH string "Internal: getCurrentStage: start year in future" ;

                                 FAILWITH }

                               {} ;

                             PUSH nat 48 ;

                             MUL ;

                             DIP { PUSH int -1 ;

                                   ADD ;

                                   ISNAT ;

                                   IF_NONE

                                     { PUSH string "Internal: getCurrentStage: month = 0" ;

                                       FAILWITH }

                                     {} ;

                                   PUSH nat 4 ;

                                   MUL } ;

                             ADD ;

                             DIP { DUP ;

                                   PUSH nat 8 ;

                                   COMPARE ;

                                   GT ;

                                   IF

                                     { DROP ; PUSH nat 0 }

                                     { DUP ;

                                       PUSH nat 15 ;

                                       COMPARE ;

                                       GT ;

                                       IF

                                         { DROP ; PUSH nat 1 }

                                         { PUSH nat 22 ;

                                           COMPARE ;

                                           GT ;

                                           IF { PUSH nat 2 } { PUSH nat 3 } } } } ;

                             ADD ;

                             DUP ;

                             DIP { SWAP } ;

                             COMPARE ;

                             DUP ;

                             EQ ;

                             IF

                               { DROP ; DROP ; DROP }

                               { LT ;

                                 IF

                                   { DROP ; PUSH string "WrongStage" ; PAIR ; FAILWITH }

                                   { DUP ;

                                     DIP { DIP { PUSH nat 4 ;

                                                 SWAP ;

                                                 EDIV ;

                                                 IF_NONE

                                                   { PUSH string "Internal: splitCounter: unexpected (1)" ;

                                                     FAILWITH }

                                                   {} ;

                                                 DUP ;

                                                 CAR ;

                                                 DIP { CDR } ;

                                                 DIP {} ;

                                                 DIP { DROP } } ;

                                           PUSH nat 4 ;

                                           SWAP ;

                                           EDIV ;

                                           IF_NONE

                                             { PUSH string "Internal: splitCounter: unexpected (1)" ;

                                               FAILWITH }

                                             {} ;

                                           DUP ;

                                           CAR ;

                                           DIP { CDR } ;

                                           DIP {} ;

                                           DIP { DROP } ;

                                           COMPARE ;

                                           EQ ;

                                           IF

                                             {}

                                             { DUP ;

                                               DUP ;

                                               CAR ;

                                               CDR ;

                                               CDR ;

                                               CDR ;

                                               EMPTY_MAP nat nat ;

                                               SWAP ;

                                               ITER { DIP { DUP } ;

                                                      CDR ;

                                                      DUP ;

                                                      DIP { SWAP } ;

                                                      GET ;

                                                      IF_NONE

                                                        { DIP { PUSH (option nat) (Some 1) } ;

                                                          UPDATE }

                                                        { PUSH nat 1 ; ADD ; SOME ; SWAP ; UPDATE } } ;

                                               NONE (map string (pair bytes string)) ;

                                               SWAP ;

                                               DIG 2 ;

                                               DUP ;

                                               CAR ;

                                               CAR ;

                                               CDR ;

                                               SIZE ;

                                               SWAP ;

                                               DIP { SWAP } ;

                                               CAR ;

                                               CDR ;

                                               CDR ;

                                               CAR ;

                                               PUSH nat 0 ;

                                               SWAP ;

                                               ITER { CAR ;

                                                      DIP { DUP ;

                                                            DIP { DIP { DUP ; DUG 3 } ;

                                                                  GET ;

                                                                  IF_NONE

                                                                    { PUSH nat 0 }

                                                                    {} ;

                                                                  PUSH nat 2 ;

                                                                  MUL ;

                                                                  DIP { DUP } ;

                                                                  COMPARE ;

                                                                  GT } } ;

                                                      DIG 4 ;

                                                      DIG 3 ;

                                                      IF

                                                        { IF_NONE

                                                            { CDR ; SOME }

                                                            { PUSH string "Internal: \"calcWinner: more than one winner\"" ;

                                                              FAILWITH } }

                                                        { DIP { DROP } } ;

                                                      DUG 3 ;

                                                      DIP { SWAP } ;

                                                      PUSH nat 1 ;

                                                      ADD } ;

                                               DROP ;

                                               DROP ;

                                               DROP ;

                                               IF_NONE

                                                 {}

                                                 { DIP { DUP ; DIP { CDR } ; CAR } ;

                                                   DIP { DUP ; DIP { CAR } ; CDR } ;

                                                   DIP { DUP ; DIP { CDR } ; CAR } ;

                                                   DIP { DROP } ;

                                                   PAIR ;

                                                   SWAP ;

                                                   PAIR ;

                                                   PAIR } ;

                                               NIL (pair

                                                     (pair string

                                                           (map string

                                                                (pair bytes string)))

                                                     bytes) ;

                                               DIP { DUP ; DIP { CDR } ; CAR } ;

                                               DIP { DUP ; DIP { CAR } ; CDR } ;

                                               DIP { DUP ; DIP { CAR } ; CDR } ;

                                               DIP { DUP ; DIP { CDR } ; CAR } ;

                                               DIP { DROP } ;

                                               PAIR ;

                                               SWAP ;

                                               PAIR ;

                                               SWAP ;

                                               PAIR ;

                                               PAIR ;

                                               EMPTY_MAP key_hash nat ;

                                               DIP { DUP ; DIP { CDR } ; CAR } ;

                                               DIP { DUP ; DIP { CAR } ; CDR } ;

                                               DIP { DUP ; DIP { CAR } ; CDR } ;

                                               DIP { DUP ; DIP { CAR } ; CDR } ;

                                               DIP { DROP } ;

                                               SWAP ;

                                               PAIR ;

                                               SWAP ;

                                               PAIR ;

                                               SWAP ;

                                               PAIR ;

                                               PAIR } } ;

                                     DIP { DUP ; DIP { CAR } ; CDR } ;

                                     DIP { DUP ; DIP { CDR } ; CAR } ;

                                     DIP { DUP ; DIP { CDR } ; CAR } ;

                                     DIP { DROP } ;

                                     PAIR ;

                                     PAIR ;

                                     SWAP ;

                                     PAIR } } } ;

                       DIP { DUP ;

                             CDR ;

                             CAR ;

                             CAR ;

                             DUP ;

                             PUSH nat 4 ;

                             SWAP ;

                             EDIV ;

                             IF_NONE

                               { PUSH string "Internal: splitCounter: unexpected (1)" ;

                                 FAILWITH }

                               {} ;

                             DUP ;

                             CAR ;

                             DIP { CDR } ;

                             DIP {} ;

                             DROP ;

                             PUSH nat 2 ;

                             COMPARE ;

                             EQ ;

                             IF

                               { DROP }

                               { PUSH string "WrongStage" ; PAIR ; FAILWITH } } ;

                       DIP { DUP } ;

                       DUP ;

                       CDR ;

                       CAR ;

                       DUP ;

                       HASH_KEY ;

                       DIP { DIG 2 } ;

                       DUP ;

                       DIP 2 { DUP ; CAR ; CAR ; CDR } ;

                       DUG 2 ;

                       MEM ;

                       IF

                         { DIP { CAR ; CDR ; CDR ; CDR } ;

                           GET ;

                           IF_NONE

                             {}

                             { PUSH string "VoteAlreadySubmitted" ; PAIR ; FAILWITH } }

                         { PUSH string "NotInCouncil" ; PAIR ; FAILWITH } ;

                       DIP { DIP { DUP } ;

                             DUP ;

                             CAR ;

                             DIP { CDR ; CDR ; SWAP ; CAR ; CDR ; CDR ; CAR } } ;

                       DUG 2 ;

                       DUP ;

                       DIG 2 ;

                       DIP { INT ;

                             NONE (pair (pair string (map string (pair bytes string)))

                                        bytes) } ;

                       ITER { DIP { SWAP } ;

                              SWAP ;

                              DUP ;

                              EQ ;

                              IF { DIP 2 { DROP } ; DIP { SOME } } { SWAP ; DROP } ;

                              PUSH int 1 ;

                              SWAP ;

                              SUB ;

                              SWAP } ;

                       DIP { DROP } ;

                       IF_NONE

                         { PUSH string "InvalidProposalId" ; PAIR ; FAILWITH }

                         { CDR ;

                           DUP ;

                           DIP { SELF ;

                                 ADDRESS ;

                                 DIP { DIP 4 { DUP ; CDR ; CAR ; CAR } ; DIG 4 } ;

                                 PAIR } ;

                           PAIR ;

                           DIP { DROP } ;

                           PACK ;

                           DIG 2 ;

                           DUP ;

                           DIP { DIP { DIG 2 } ;

                                 DUP ;

                                 DIP { CHECK_SIGNATURE } ;

                                 SWAP ;

                                 IF

                                   { DROP }

                                   { PUSH string "InvalidSignature" ; PAIR ; FAILWITH } } ;

                           HASH_KEY ;

                           DIP { SOME } ;

                           DIP 2 { DUP ; CAR ; CDR ; CDR ; CDR } ;

                           UPDATE ;

                           DIP { DUP ; DIP { CDR } ; CAR } ;

                           DIP { DUP ; DIP { CAR } ; CDR } ;

                           DIP { DUP ; DIP { CAR } ; CDR } ;

                           DIP { DUP ; DIP { CAR } ; CDR } ;

                           DIP { DROP } ;

                           SWAP ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           SWAP ;

                           PAIR ;

                           PAIR } ;

                       NIL operation ;

                       PAIR }

                     { DUP ;

                       CAR ;

                       DIP { CDR } ;

                       DIP { DIP { DUP } ; SWAP } ;

                       PAIR ;

                       DUP ;

                       CAR ;

                       DIP { CDR } ;

                       DIP { CDR ; CDR ; CAR } ;

                       GET ;

                       IF_NONE { PUSH nat 0 } {} ;

                       DIP { AMOUNT } ;

                       TRANSFER_TOKENS ;

                       NIL operation ;

                       SWAP ;

                       CONS ;

                       PAIR } }

                 { IF_LEFT

                     { DUP ;

                       CAR ;

                       DIP { CDR } ;

                       DIP { DIP { DUP } ; SWAP } ;

                       PAIR ;

                       DUP ;

                       CAR ;

                       DIP { CDR } ;

                       DROP ;

                       CDR ;

                       CAR ;

                       CDR ;

                       DIP { AMOUNT } ;

                       TRANSFER_TOKENS ;

                       NIL operation ;

                       SWAP ;

                       CONS ;

                       PAIR }

                     { DROP ; NIL operation ; PAIR } } }

             { SWAP ; EXEC ; NIL operation ; SWAP ; CONS ; PAIR } }

         { IF_LEFT

             { DIP { DUP } ;

               SWAP ;

               CDR ;

               CDR ;

               CDR ;

               CAR ;

               IF

                 { PUSH unit Unit ; PUSH string "ContractFrozen" ; PAIR ; FAILWITH }

                 {} ;

               DIP { DUP } ;

               SWAP ;

               SWAP ;

               DIP { CAR ;

                     CAR ;

                     CAR ;

                     SENDER ;

                     DIP { DUP } ;

                     COMPARE ;

                     EQ ;

                     IF { DROP } { PUSH string "SenderCheckFailed" ; PAIR ; FAILWITH } } ;

               IF_LEFT

                 { IF_LEFT

                     { DIP { DUP ;

                             CDR ;

                             CAR ;

                             CAR ;

                             DUP ;

                             NOW ;

                             PUSH timestamp "1858-11-17T00:00:00Z" ;

                             SWAP ;

                             SUB ;

                             DIP { PUSH nat 86400 } ;

                             EDIV ;

                             IF_NONE

                               { PUSH string "Internal: extractDate: unexpected (1)" ;

                                 FAILWITH }

                               {} ;

                             CAR ;

                             PUSH nat 678575 ;

                             ADD ;

                             DIP { PUSH nat 146097 } ;

                             EDIV ;

                             IF_NONE

                               { PUSH string "Internal: toOrdinalDate: unexpected (1)" ;

                                 FAILWITH }

                               {} ;

                             DUP ;

                             CAR ;

                             DIP { CDR } ;

                             DIP { DUP ;

                                   DIP { PUSH nat 36524 } ;

                                   EDIV ;

                                   IF_NONE

                                     { PUSH string "Internal: toOrdinalDate: unexpected (2)" ;

                                       FAILWITH }

                                     {} ;

                                   CAR ;

                                   DUP ;

                                   PUSH nat 3 ;

                                   COMPARE ;

                                   GT ;

                                   IF {} { DROP ; PUSH nat 3 } ;

                                   DUP ;

                                   DIP { SWAP } ;

                                   PUSH nat 36524 ;

                                   MUL ;

                                   SWAP ;

                                   SUB ;

                                   DIP { PUSH nat 1461 } ;

                                   EDIV ;

                                   IF_NONE

                                     { PUSH string "Internal: toOrdinalDate: unexpected (3)" ;

                                       FAILWITH }

                                     {} ;

                                   DUP ;

                                   CAR ;

                                   DIP { CDR } ;

                                   SWAP ;

                                   DUP ;

                                   DIP { DIP { PUSH nat 365 } ;

                                         EDIV ;

                                         IF_NONE

                                           { PUSH string "Internal: toOrdinalDate: unexpected (4)" ;

                                             FAILWITH }

                                           {} ;

                                         CAR ;

                                         DUP ;

                                         PUSH nat 3 ;

                                         COMPARE ;

                                         GT ;

                                         IF {} { DROP ; PUSH nat 3 } ;

                                         DUP ;

                                         DIP {} ;

                                         PUSH nat 365 ;

                                         MUL } ;

                                   SUB ;

                                   PUSH nat 1 ;

                                   ADD ;

                                   ISNAT ;

                                   IF_NONE

                                     { PUSH string "Internal: toOrdinalDate: unexpected (5)" ;

                                       FAILWITH }

                                     {} } ;

                             SWAP ;

                             DIP { PUSH nat 400 ;

                                   MUL ;

                                   PUSH nat 1 ;

                                   ADD ;

                                   DIP {} ;

                                   ADD ;

                                   DIP { PUSH nat 4 ; MUL } ;

                                   ADD ;

                                   DIP { PUSH nat 100 ; MUL } ;

                                   ADD } ;

                             SWAP ;

                             DUP ;

                             DIP { DUP ;

                                   DIP { DUP } ;

                                   DIP { PUSH nat 400 } ;

                                   EDIV ;

                                   IF_NONE

                                     { PUSH string "Internal: isLeap: unexpected (1)" ;

                                       FAILWITH }

                                     {} ;

                                   CDR ;

                                   INT ;

                                   EQ ;

                                   SWAP ;

                                   DIP { PUSH nat 100 } ;

                                   EDIV ;

                                   IF_NONE

                                     { PUSH string "Internal: isLeap: unexpected (1)" ;

                                       FAILWITH }

                                     {} ;

                                   CDR ;

                                   INT ;

                                   NEQ ;

                                   OR ;

                                   SWAP ;

                                   DIP { PUSH nat 4 } ;

                                   EDIV ;

                                   IF_NONE

                                     { PUSH string "Internal: isLeap: unexpected (1)" ;

                                       FAILWITH }

                                     {} ;

                                   CDR ;

                                   INT ;

                                   EQ ;

                                   AND ;

                                   PUSH (list nat) { 31 ; 30 ; 31 ; 30 ; 31 ; 31 ; 30 ; 31 ; 30 ; 31 } ;

                                   SWAP ;

                                   IF { PUSH nat 29 } { PUSH nat 28 } ;

                                   CONS ;

                                   PUSH nat 31 ;

                                   CONS ;

                                   DIP { PUSH nat 1 ;

                                         SWAP ;

                                         SUB ;

                                         ISNAT ;

                                         IF_NONE

                                           { PUSH string "Internal: yearDayToMonthAndDay: year day <= 1" ;

                                             FAILWITH }

                                           {} ;

                                         SOME ;

                                         DIP { NONE nat ; PUSH nat 0 } } ;

                                   ITER { SWAP ;

                                          IF_NONE

                                            { DROP ; NONE nat }

                                            { DIP 2 { PUSH nat 1 ; ADD } ;

                                              DUP ;

                                              DIP { SWAP } ;

                                              SUB ;

                                              ISNAT ;

                                              IF_NONE

                                                { SWAP ;

                                                  DIP { DIP { DROP } ; PUSH nat 1 ; ADD ; SOME } ;

                                                  NONE nat }

                                                { DIP { DROP } ; SOME } } } ;

                                   DROP ;

                                   DIP { IF_NONE

                                           { PUSH string "Internal: yearDayToMonthAndDay: year day is greater than number of days in year" ;

                                             FAILWITH }

                                           {} } } ;

                             PUSH nat 2020 ;

                             SWAP ;

                             SUB ;

                             ISNAT ;

                             IF_NONE

                               { PUSH string "Internal: getCurrentStage: start year in future" ;

                                 FAILWITH }

                               {} ;

                             PUSH nat 48 ;

                             MUL ;

                             DIP { PUSH int -1 ;

                                   ADD ;

                                   ISNAT ;

                                   IF_NONE

                                     { PUSH string "Internal: getCurrentStage: month = 0" ;

                                       FAILWITH }

                                     {} ;

                                   PUSH nat 4 ;

                                   MUL } ;

                             ADD ;

                             DIP { DUP ;

                                   PUSH nat 8 ;

                                   COMPARE ;

                                   GT ;

                                   IF

                                     { DROP ; PUSH nat 0 }

                                     { DUP ;

                                       PUSH nat 15 ;

                                       COMPARE ;

                                       GT ;

                                       IF

                                         { DROP ; PUSH nat 1 }

                                         { PUSH nat 22 ;

                                           COMPARE ;

                                           GT ;