diff --git a/src/bin/expect_tests/contract_tests.ml b/src/bin/expect_tests/contract_tests.ml
index 0de81c536..98b286f3a 100644
--- a/src/bin/expect_tests/contract_tests.ml
+++ b/src/bin/expect_tests/contract_tests.ml
@@ -7,16 +7,16 @@ let bad_contract basename =
 
 let%expect_test _ =
   run_ligo_good [ "measure-contract" ; contract "coase.ligo" ; "main" ] ;
-  [%expect {| 1842 bytes |}] ;
+  [%expect {| 1682 bytes |}] ;
 
   run_ligo_good [ "measure-contract" ; contract "multisig.ligo" ; "main" ] ;
-  [%expect {| 1138 bytes |}] ;
+  [%expect {| 1003 bytes |}] ;
 
   run_ligo_good [ "measure-contract" ; contract "multisig-v2.ligo" ; "main" ] ;
-  [%expect {| 2797 bytes |}] ;
+  [%expect {| 2522 bytes |}] ;
 
   run_ligo_good [ "measure-contract" ; contract "vote.mligo" ; "main" ] ;
-  [%expect {| 626 bytes |}] ;
+  [%expect {| 586 bytes |}] ;
 
   run_ligo_good [ "compile-parameter" ; contract "coase.ligo" ; "main" ; "Buy_single (record card_to_buy = 1n end)" ] ;
   [%expect {| (Left (Left 1)) |}] ;
@@ -74,8 +74,9 @@ let%expect_test _ =
          IF_LEFT
            { DUP ;
              IF_LEFT
-               { DIP 2 { DUP } ;
-                 DIG 2 ;
+               { DIG 2 ;
+                 DUP ;
+                 DUG 3 ;
                  DIP { DUP } ;
                  SWAP ;
                  PAIR ;
@@ -87,8 +88,9 @@ let%expect_test _ =
                  DUP ;
                  CAR ;
                  CAR ;
-                 DIP 2 { DUP } ;
                  DIG 2 ;
+                 DUP ;
+                 DUG 3 ;
                  GET ;
                  IF_NONE
                    { PUSH string "buy_single: No card pattern." ; FAILWITH }
@@ -108,26 +110,32 @@ let%expect_test _ =
                  COMPARE ;
                  GT ;
                  IF { PUSH string "Not enough money" ; FAILWITH } { PUSH unit Unit } ;
-                 DIP 2 { DUP } ;
                  DIG 2 ;
+                 DUP ;
+                 DUG 3 ;
                  PUSH nat 1 ;
-                 DIP 4 { DUP } ;
                  DIG 4 ;
+                 DUP ;
+                 DUG 5 ;
                  CDR ;
                  ADD ;
                  SWAP ;
                  CAR ;
                  PAIR ;
-                 DIP 4 { DUP } ;
                  DIG 4 ;
-                 DIP 5 { DUP } ;
+                 DUP ;
+                 DUG 5 ;
                  DIG 5 ;
+                 DUP ;
+                 DUG 6 ;
                  CAR ;
                  CAR ;
-                 DIP 2 { DUP } ;
                  DIG 2 ;
-                 DIP 8 { DUP } ;
+                 DUP ;
+                 DUG 3 ;
                  DIG 8 ;
+                 DUP ;
+                 DUG 9 ;
                  SWAP ;
                  SOME ;
                  SWAP ;
@@ -138,12 +146,14 @@ let%expect_test _ =
                  DUP ;
                  CAR ;
                  CDR ;
-                 DIP 7 { DUP } ;
                  DIG 7 ;
+                 DUP ;
+                 DUG 8 ;
                  SENDER ;
                  PAIR ;
-                 DIP 2 { DUP } ;
                  DIG 2 ;
+                 DUP ;
+                 DUG 3 ;
                  CDR ;
                  SWAP ;
                  SOME ;
@@ -159,8 +169,9 @@ let%expect_test _ =
                  PAIR ;
                  DUP ;
                  PUSH nat 1 ;
-                 DIP 2 { DUP } ;
                  DIG 2 ;
+                 DUP ;
+                 DUG 3 ;
                  CDR ;
                  ADD ;
                  SWAP ;
@@ -170,8 +181,9 @@ let%expect_test _ =
                  NIL operation ;
                  PAIR ;
                  DIP { DROP 12 } }
-               { DIP 2 { DUP } ;
-                 DIG 2 ;
+               { DIG 2 ;
+                 DUP ;
+                 DUG 3 ;
                  DIP { DUP } ;
                  SWAP ;
                  PAIR ;
@@ -183,8 +195,9 @@ let%expect_test _ =
                  DUP ;
                  CAR ;
                  CDR ;
-                 DIP 2 { DUP } ;
                  DIG 2 ;
+                 DUP ;
+                 DUG 3 ;
                  GET ;
                  IF_NONE
                    { PUSH string "sell_single: No card." ; FAILWITH }
@@ -197,12 +210,14 @@ let%expect_test _ =
                  NEQ ;
                  IF { PUSH string "This card doesn't belong to you" ; FAILWITH }
                     { PUSH unit Unit } ;
-                 DIP 2 { DUP } ;
                  DIG 2 ;
+                 DUP ;
+                 DUG 3 ;
                  CAR ;
                  CAR ;
-                 DIP 2 { DUP } ;
                  DIG 2 ;
+                 DUP ;
+                 DUG 3 ;
                  CDR ;
                  GET ;
                  IF_NONE
@@ -210,24 +225,29 @@ let%expect_test _ =
                    { DUP ; DIP { DROP } } ;
                  DUP ;
                  PUSH nat 1 ;
-                 DIP 2 { DUP } ;
                  DIG 2 ;
+                 DUP ;
+                 DUG 3 ;
                  CDR ;
                  SUB ;
                  ABS ;
                  SWAP ;
                  CAR ;
                  PAIR ;
-                 DIP 4 { DUP } ;
                  DIG 4 ;
-                 DIP 5 { DUP } ;
+                 DUP ;
+                 DUG 5 ;
                  DIG 5 ;
+                 DUP ;
+                 DUG 6 ;
                  CAR ;
                  CAR ;
-                 DIP 2 { DUP } ;
                  DIG 2 ;
-                 DIP 6 { DUP } ;
+                 DUP ;
+                 DUG 3 ;
                  DIG 6 ;
+                 DUP ;
+                 DUG 7 ;
                  CDR ;
                  SWAP ;
                  SOME ;
@@ -239,16 +259,19 @@ let%expect_test _ =
                  DUP ;
                  CAR ;
                  CDR ;
-                 DIP 7 { DUP } ;
                  DIG 7 ;
+                 DUP ;
+                 DUG 8 ;
                  NONE (pair (address %card_owner) (nat %card_pattern)) ;
                  SWAP ;
                  UPDATE ;
-                 DIP 2 { DUP } ;
                  DIG 2 ;
+                 DUP ;
+                 DUG 3 ;
                  CDR ;
-                 DIP 3 { DUP } ;
                  DIG 3 ;
+                 DUP ;
+                 DUG 4 ;
                  CAR ;
                  MUL ;
                  SENDER ;
@@ -257,18 +280,21 @@ let%expect_test _ =
                    { PUSH string "sell_single: No contract." ; FAILWITH }
                    { DUP ; DIP { DROP } } ;
                  DUP ;
-                 DIP 2 { DUP } ;
                  DIG 2 ;
+                 DUP ;
+                 DUG 3 ;
                  UNIT ;
                  TRANSFER_TOKENS ;
                  DUP ;
                  NIL operation ;
                  SWAP ;
                  CONS ;
-                 DIP 5 { DUP } ;
                  DIG 5 ;
-                 DIP 5 { DUP } ;
+                 DUP ;
+                 DUG 6 ;
                  DIG 5 ;
+                 DUP ;
+                 DUG 6 ;
                  DIP { DUP ; CDR ; SWAP ; CAR ; CAR } ;
                  SWAP ;
                  PAIR ;
@@ -292,8 +318,9 @@ let%expect_test _ =
              CAR ;
              CDR ;
              DUP ;
-             DIP 3 { DUP } ;
              DIG 3 ;
+             DUP ;
+             DUG 4 ;
              CAR ;
              GET ;
              IF_NONE
@@ -307,21 +334,26 @@ let%expect_test _ =
              NEQ ;
              IF { PUSH string "This card doesn't belong to you" ; FAILWITH }
                 { PUSH unit Unit } ;
-             DIP 3 { DUP } ;
              DIG 3 ;
-             DIP 3 { DUP } ;
+             DUP ;
+             DUG 4 ;
              DIG 3 ;
-             DIP 3 { DUP } ;
+             DUP ;
+             DUG 4 ;
              DIG 3 ;
-             DIP 7 { DUP } ;
+             DUP ;
+             DUG 4 ;
              DIG 7 ;
+             DUP ;
+             DUG 8 ;
              CDR ;
              SWAP ;
              CDR ;
              SWAP ;
              PAIR ;
-             DIP 7 { DUP } ;
              DIG 7 ;
+             DUP ;
+             DUG 8 ;
              CAR ;
              SWAP ;
              SOME ;
@@ -339,401 +371,146 @@ let%expect_test _ =
 let%expect_test _ =
   run_ligo_good [ "compile-contract" ; contract "multisig-v2.ligo" ; "main" ] ;
   [%expect {|
-    { parameter
-        (or (or (unit %default) (lambda %send bytes (list operation)))
-            (lambda %withdraw bytes (list operation))) ;
-      storage
-        (pair (pair (pair (set %authorized_addresses address) (nat %max_message_size))
-                    (pair (nat %max_proposal) (map %message_store bytes (set address))))
-              (pair (pair (map %proposal_counters address nat) (bytes %state_hash))
-                    (nat %threshold))) ;
-      code { DUP ;
-             CDR ;
-             DIP { DUP } ;
-             SWAP ;
-             CAR ;
+{ parameter
+    (or (or (unit %default) (lambda %send bytes (list operation)))
+        (lambda %withdraw bytes (list operation))) ;
+  storage
+    (pair (pair (pair (set %authorized_addresses address) (nat %max_message_size))
+                (pair (nat %max_proposal) (map %message_store bytes (set address))))
+          (pair (pair (map %proposal_counters address nat) (bytes %state_hash))
+                (nat %threshold))) ;
+  code { DUP ;
+         CDR ;
+         DIP { DUP } ;
+         SWAP ;
+         CAR ;
+         IF_LEFT
+           { DUP ;
              IF_LEFT
-               { DUP ;
-                 IF_LEFT
-                   { DIP 2 { DUP } ; DIG 2 ; NIL operation ; PAIR ; DIP { DROP } }
-                   { DIP 2 { DUP } ;
-                     DIG 2 ;
-                     DIP { DUP } ;
-                     SWAP ;
-                     PAIR ;
+               { DIG 2 ; DUP ; DUG 3 ; NIL operation ; PAIR ; DIP { DROP } }
+               { DIG 2 ;
+                 DUP ;
+                 DUG 3 ;
+                 DIP { DUP } ;
+                 SWAP ;
+                 PAIR ;
+                 DUP ;
+                 CDR ;
+                 DUP ;
+                 CAR ;
+                 CAR ;
+                 CAR ;
+                 SENDER ;
+                 MEM ;
+                 NOT ;
+                 IF { PUSH string "Unauthorized address" ; FAILWITH } { PUSH unit Unit } ;
+                 DIG 2 ;
+                 DUP ;
+                 DUG 3 ;
+                 CAR ;
+                 DUP ;
+                 PACK ;
+                 DIG 3 ;
+                 DUP ;
+                 DUG 4 ;
+                 CAR ;
+                 CAR ;
+                 CDR ;
+                 DIP { DUP } ;
+                 SWAP ;
+                 SIZE ;
+                 COMPARE ;
+                 GT ;
+                 IF { PUSH string "Message size exceed maximum limit" ; FAILWITH }
+                    { PUSH unit Unit } ;
+                 EMPTY_SET address ;
+                 DIG 5 ;
+                 DUP ;
+                 DUG 6 ;
+                 DIP { DUP } ;
+                 SWAP ;
+                 PAIR ;
+                 DIG 6 ;
+                 DUP ;
+                 DUG 7 ;
+                 CAR ;
+                 CDR ;
+                 CDR ;
+                 DIG 4 ;
+                 DUP ;
+                 DUG 5 ;
+                 GET ;
+                 IF_NONE
+                   { DIG 6 ;
                      DUP ;
-                     CDR ;
+                     DUG 7 ;
+                     DIG 7 ;
                      DUP ;
+                     DUG 8 ;
+                     CDR ;
                      CAR ;
                      CAR ;
-                     CAR ;
-                     SENDER ;
-                     MEM ;
-                     NOT ;
-                     IF { PUSH string "Unauthorized address" ; FAILWITH } { PUSH unit Unit } ;
-                     DIP 2 { DUP } ;
-                     DIG 2 ;
-                     CAR ;
-                     DUP ;
-                     PACK ;
-                     DIP 3 { DUP } ;
-                     DIG 3 ;
-                     CAR ;
-                     CAR ;
-                     CDR ;
-                     DIP { DUP } ;
-                     SWAP ;
-                     SIZE ;
-                     COMPARE ;
-                     GT ;
-                     IF { PUSH string "Message size exceed maximum limit" ; FAILWITH }
-                        { PUSH unit Unit } ;
-                     EMPTY_SET address ;
-                     DIP 5 { DUP } ;
-                     DIG 5 ;
-                     DIP { DUP } ;
-                     SWAP ;
-                     PAIR ;
-                     DIP 6 { DUP } ;
-                     DIG 6 ;
-                     CAR ;
-                     CDR ;
-                     CDR ;
-                     DIP 4 { DUP } ;
-                     DIG 4 ;
-                     GET ;
-                     IF_NONE
-                       { DIP 6 { DUP } ;
-                         DIG 6 ;
-                         DIP 7 { DUP } ;
-                         DIG 7 ;
-                         CDR ;
-                         CAR ;
-                         CAR ;
-                         PUSH nat 1 ;
-                         DIP 9 { DUP } ;
-                         DIG 9 ;
-                         CDR ;
-                         CAR ;
-                         CAR ;
-                         SENDER ;
-                         GET ;
-                         IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
-                         ADD ;
-                         SOME ;
-                         SENDER ;
-                         UPDATE ;
-                         DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CDR } ;
-                         PAIR ;
-                         PAIR ;
-                         SWAP ;
-                         PAIR ;
-                         EMPTY_SET address ;
-                         PUSH bool True ;
-                         SENDER ;
-                         UPDATE ;
-                         DIP 2 { DUP } ;
-                         DIG 2 ;
-                         DIP 2 { DUP } ;
-                         DIG 2 ;
-                         SWAP ;
-                         CAR ;
-                         PAIR ;
-                         CDR ;
-                         DIP { DUP } ;
-                         SWAP ;
-                         PAIR ;
-                         DIP { DROP 2 } }
-                       { DUP ;
-                         SENDER ;
-                         MEM ;
-                         IF { DIP 7 { DUP } ; DIG 7 }
-                            { DIP 7 { DUP } ;
-                              DIG 7 ;
-                              DIP 8 { DUP } ;
-                              DIG 8 ;
-                              CDR ;
-                              CAR ;
-                              CAR ;
-                              PUSH nat 1 ;
-                              DIP 10 { DUP } ;
-                              DIG 10 ;
-                              CDR ;
-                              CAR ;
-                              CAR ;
-                              SENDER ;
-                              GET ;
-                              IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
-                              ADD ;
-                              SOME ;
-                              SENDER ;
-                              UPDATE ;
-                              DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CDR } ;
-                              PAIR ;
-                              PAIR ;
-                              SWAP ;
-                              PAIR ;
-                              DIP 8 { DUP } ;
-                              DIG 8 ;
-                              DIP { DUP } ;
-                              SWAP ;
-                              DIP { DROP 2 } } ;
-                         DIP { DUP } ;
-                         SWAP ;
-                         PUSH bool True ;
-                         SENDER ;
-                         UPDATE ;
-                         DIP 3 { DUP } ;
-                         DIG 3 ;
-                         DIP 2 { DUP } ;
-                         DIG 2 ;
-                         SWAP ;
-                         CAR ;
-                         PAIR ;
-                         CDR ;
-                         DIP { DUP } ;
-                         SWAP ;
-                         PAIR ;
-                         DIP { DROP 3 } } ;
-                     DUP ;
-                     CAR ;
-                     DIP { DUP } ;
-                     SWAP ;
-                     CDR ;
+                     PUSH nat 1 ;
+                     DIG 9 ;
                      DUP ;
+                     DUG 10 ;
                      CDR ;
                      CAR ;
                      CAR ;
                      SENDER ;
                      GET ;
                      IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
-                     DIP { DUP } ;
+                     ADD ;
+                     SOME ;
+                     SENDER ;
+                     UPDATE ;
+                     DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CDR } ;
+                     PAIR ;
+                     PAIR ;
+                     SWAP ;
+                     PAIR ;
+                     EMPTY_SET address ;
+                     PUSH bool True ;
+                     SENDER ;
+                     UPDATE ;
+                     DIG 2 ;
+                     DUP ;
+                     DUG 3 ;
+                     DIG 2 ;
+                     DUP ;
+                     DUG 3 ;
                      SWAP ;
                      CAR ;
+                     PAIR ;
                      CDR ;
-                     CAR ;
-                     DIP { DUP } ;
-                     SWAP ;
-                     COMPARE ;
-                     GT ;
-                     IF { PUSH string "Maximum number of proposal reached" ; FAILWITH }
-                        { PUSH unit Unit } ;
-                     NIL operation ;
-                     DIP 3 { DUP } ;
-                     DIG 3 ;
                      DIP { DUP } ;
                      SWAP ;
                      PAIR ;
-                     DIP 4 { DUP } ;
-                     DIG 4 ;
-                     CDR ;
-                     CDR ;
-                     DIP 6 { DUP } ;
-                     DIG 6 ;
-                     SIZE ;
-                     COMPARE ;
-                     GE ;
-                     IF { DIP 4 { DUP } ;
-                          DIG 4 ;
-                          DIP 5 { DUP } ;
-                          DIG 5 ;
-                          CAR ;
-                          CDR ;
-                          CDR ;
-                          DIP 12 { DUP } ;
-                          DIG 12 ;
-                          NONE (set address) ;
-                          SWAP ;
-                          UPDATE ;
-                          DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CAR ; SWAP ; CDR ; CAR } ;
-                          SWAP ;
-                          PAIR ;
-                          SWAP ;
-                          PAIR ;
-                          PAIR ;
-                          DUP ;
-                          CDR ;
-                          CAR ;
-                          CDR ;
-                          DIP 13 { DUP } ;
-                          DIG 13 ;
-                          SWAP ;
-                          EXEC ;
-                          DIP { DUP } ;
-                          SWAP ;
-                          DIP 13 { DUP } ;
-                          DIG 13 ;
-                          DIP 3 { DUP } ;
-                          DIG 3 ;
-                          CDR ;
-                          CAR ;
-                          CDR ;
-                          CONCAT ;
-                          SHA256 ;
-                          DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CAR } ;
-                          SWAP ;
-                          PAIR ;
-                          PAIR ;
-                          SWAP ;
-                          PAIR ;
-                          DUP ;
-                          DIP { DUP } ;
-                          SWAP ;
-                          CDR ;
-                          CAR ;
-                          CAR ;
-                          ITER { SWAP ;
-                                 PAIR ;
-                                 DUP ;
-                                 CAR ;
-                                 DIP { DUP } ;
-                                 SWAP ;
-                                 CDR ;
-                                 CAR ;
-                                 DIP 11 { DUP } ;
-                                 DIG 11 ;
-                                 DIP { DUP } ;
-                                 SWAP ;
-                                 MEM ;
-                                 IF { DIP { DUP } ;
-                                      SWAP ;
-                                      DIP 2 { DUP } ;
-                                      DIG 2 ;
-                                      CDR ;
-                                      CAR ;
-                                      CAR ;
-                                      PUSH nat 1 ;
-                                      DIP 5 { DUP } ;
-                                      DIG 5 ;
-                                      CDR ;
-                                      CDR ;
-                                      SUB ;
-                                      ABS ;
-                                      DIP 3 { DUP } ;
-                                      DIG 3 ;
-                                      SWAP ;
-                                      SOME ;
-                                      SWAP ;
-                                      UPDATE ;
-                                      DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CDR } ;
-                                      PAIR ;
-                                      PAIR ;
-                                      SWAP ;
-                                      PAIR ;
-                                      DIP 2 { DUP } ;
-                                      DIG 2 ;
-                                      DIP { DUP } ;
-                                      SWAP ;
-                                      DIP { DROP 2 } }
-                                    { DIP { DUP } ; SWAP } ;
-                                 DIP 3 { DUP } ;
-                                 DIG 3 ;
-                                 CDR ;
-                                 DIP { DUP } ;
-                                 SWAP ;
-                                 PAIR ;
-                                 CAR ;
-                                 DIP { DROP 4 } } ;
-                          DIP 4 { DUP } ;
-                          DIG 4 ;
-                          DIP 4 { DUP } ;
-                          DIG 4 ;
-                          SWAP ;
-                          CAR ;
-                          PAIR ;
-                          DIP 3 { DUP } ;
-                          DIG 3 ;
-                          SWAP ;
-                          CDR ;
-                          SWAP ;
-                          PAIR ;
-                          DIP 2 { DUP } ;
-                          DIG 2 ;
-                          SWAP ;
-                          CAR ;
-                          PAIR ;
-                          CAR ;
-                          DIP { DUP } ;
-                          PAIR ;
-                          DIP { DROP 4 } }
-                        { DUP ;
-                          DIP 5 { DUP } ;
-                          DIG 5 ;
-                          DIP 6 { DUP } ;
-                          DIG 6 ;
-                          CAR ;
-                          CDR ;
-                          CDR ;
-                          DIP 8 { DUP } ;
-                          DIG 8 ;
-                          DIP 14 { DUP } ;
-                          DIG 14 ;
-                          SWAP ;
-                          SOME ;
-                          SWAP ;
-                          UPDATE ;
-                          DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CAR ; SWAP ; CDR ; CAR } ;
-                          SWAP ;
-                          PAIR ;
-                          SWAP ;
-                          PAIR ;
-                          PAIR ;
-                          SWAP ;
-                          CAR ;
-                          PAIR } ;
-                     DUP ;
-                     DIP { DROP 17 } } ;
-                 DIP { DROP } }
-               { DIP { DUP } ;
-                 SWAP ;
-                 DIP { DUP } ;
-                 SWAP ;
-                 PAIR ;
-                 DUP ;
-                 CDR ;
-                 DIP { DUP } ;
-                 SWAP ;
-                 CAR ;
-                 PACK ;
-                 DIP { DUP } ;
-                 SWAP ;
-                 CAR ;
-                 CDR ;
-                 CDR ;
-                 DIP { DUP } ;
-                 SWAP ;
-                 GET ;
-                 IF_NONE
-                   { DIP { DUP } ; SWAP }
+                     DIP { DROP 2 } }
                    { DUP ;
-                     PUSH bool False ;
                      SENDER ;
-                     UPDATE ;
-                     DUP ;
-                     SIZE ;
-                     DIP 2 { DUP } ;
-                     DIG 2 ;
-                     SIZE ;
-                     COMPARE ;
-                     NEQ ;
-                     IF { DIP 3 { DUP } ;
-                          DIG 3 ;
-                          DIP 4 { DUP } ;
-                          DIG 4 ;
+                     MEM ;
+                     IF { DIG 7 ; DUP ; DUG 8 }
+                        { DIG 7 ;
+                          DUP ;
+                          DUG 8 ;
+                          DIG 8 ;
+                          DUP ;
+                          DUG 9 ;
                           CDR ;
                           CAR ;
                           CAR ;
                           PUSH nat 1 ;
-                          DIP 6 { DUP } ;
-                          DIG 6 ;
+                          DIG 10 ;
+                          DUP ;
+                          DUG 11 ;
                           CDR ;
                           CAR ;
                           CAR ;
                           SENDER ;
                           GET ;
                           IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
-                          SUB ;
-                          ABS ;
+                          ADD ;
                           SOME ;
                           SENDER ;
                           UPDATE ;
@@ -742,75 +519,382 @@ let%expect_test _ =
                           PAIR ;
                           SWAP ;
                           PAIR ;
-                          DIP 4 { DUP } ;
-                          DIG 4 ;
+                          DIG 8 ;
+                          DUP ;
+                          DUG 9 ;
                           DIP { DUP } ;
                           SWAP ;
-                          DIP { DROP 2 } }
-                        { DIP 3 { DUP } ; DIG 3 } ;
-                     PUSH nat 0 ;
-                     DIP 2 { DUP } ;
-                     DIG 2 ;
-                     SIZE ;
-                     COMPARE ;
-                     EQ ;
-                     IF { DUP ;
-                          DIP { DUP } ;
-                          SWAP ;
-                          CAR ;
-                          CDR ;
-                          CDR ;
-                          DIP 5 { DUP } ;
-                          DIG 5 ;
-                          NONE (set address) ;
-                          SWAP ;
-                          UPDATE ;
-                          DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CAR ; SWAP ; CDR ; CAR } ;
-                          SWAP ;
-                          PAIR ;
-                          SWAP ;
-                          PAIR ;
-                          PAIR ;
-                          DIP { DUP } ;
-                          SWAP ;
-                          DIP { DUP } ;
-                          SWAP ;
-                          DIP { DROP 2 } }
-                        { DUP ;
-                          DIP { DUP } ;
-                          SWAP ;
-                          DIP 2 { DUP } ;
-                          DIG 2 ;
-                          CAR ;
-                          CDR ;
-                          CDR ;
-                          DIP 4 { DUP } ;
-                          DIG 4 ;
-                          DIP 7 { DUP } ;
-                          DIG 7 ;
-                          SWAP ;
-                          SOME ;
-                          SWAP ;
-                          UPDATE ;
-                          DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CAR ; SWAP ; CDR ; CAR } ;
-                          SWAP ;
-                          PAIR ;
-                          SWAP ;
-                          PAIR ;
-                          PAIR ;
-                          DIP { DROP } } ;
-                     DIP 5 { DUP } ;
-                     DIG 5 ;
-                     DIP 2 { DUP } ;
-                     DIG 2 ;
-                     DIP { DROP ; DUP } ;
+                          DIP { DROP 2 } } ;
+                     DIP { DUP } ;
                      SWAP ;
-                     DIP { DROP 5 } } ;
+                     PUSH bool True ;
+                     SENDER ;
+                     UPDATE ;
+                     DIG 3 ;
+                     DUP ;
+                     DUG 4 ;
+                     DIG 2 ;
+                     DUP ;
+                     DUG 3 ;
+                     SWAP ;
+                     CAR ;
+                     PAIR ;
+                     CDR ;
+                     DIP { DUP } ;
+                     SWAP ;
+                     PAIR ;
+                     DIP { DROP 3 } } ;
                  DUP ;
+                 CAR ;
+                 DIP { DUP } ;
+                 SWAP ;
+                 CDR ;
+                 DUP ;
+                 CDR ;
+                 CAR ;
+                 CAR ;
+                 SENDER ;
+                 GET ;
+                 IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
+                 DIP { DUP } ;
+                 SWAP ;
+                 CAR ;
+                 CDR ;
+                 CAR ;
+                 DIP { DUP } ;
+                 SWAP ;
+                 COMPARE ;
+                 GT ;
+                 IF { PUSH string "Maximum number of proposal reached" ; FAILWITH }
+                    { PUSH unit Unit } ;
                  NIL operation ;
+                 DIG 3 ;
+                 DUP ;
+                 DUG 4 ;
+                 DIP { DUP } ;
+                 SWAP ;
                  PAIR ;
+                 DIG 4 ;
+                 DUP ;
+                 DUG 5 ;
+                 CDR ;
+                 CDR ;
+                 DIG 6 ;
+                 DUP ;
+                 DUG 7 ;
+                 SIZE ;
+                 COMPARE ;
+                 GE ;
+                 IF { DIG 4 ;
+                      DUP ;
+                      DUG 5 ;
+                      DIG 5 ;
+                      DUP ;
+                      DUG 6 ;
+                      CAR ;
+                      CDR ;
+                      CDR ;
+                      DIG 12 ;
+                      DUP ;
+                      DUG 13 ;
+                      NONE (set address) ;
+                      SWAP ;
+                      UPDATE ;
+                      DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CAR ; SWAP ; CDR ; CAR } ;
+                      SWAP ;
+                      PAIR ;
+                      SWAP ;
+                      PAIR ;
+                      PAIR ;
+                      DUP ;
+                      CDR ;
+                      CAR ;
+                      CDR ;
+                      DIG 13 ;
+                      DUP ;
+                      DUG 14 ;
+                      SWAP ;
+                      EXEC ;
+                      DIP { DUP } ;
+                      SWAP ;
+                      DIG 13 ;
+                      DUP ;
+                      DUG 14 ;
+                      DIG 3 ;
+                      DUP ;
+                      DUG 4 ;
+                      CDR ;
+                      CAR ;
+                      CDR ;
+                      CONCAT ;
+                      SHA256 ;
+                      DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CAR } ;
+                      SWAP ;
+                      PAIR ;
+                      PAIR ;
+                      SWAP ;
+                      PAIR ;
+                      DUP ;
+                      DIP { DUP } ;
+                      SWAP ;
+                      CDR ;
+                      CAR ;
+                      CAR ;
+                      ITER { SWAP ;
+                             PAIR ;
+                             DUP ;
+                             CAR ;
+                             DIP { DUP } ;
+                             SWAP ;
+                             CDR ;
+                             CAR ;
+                             DIG 11 ;
+                             DUP ;
+                             DUG 12 ;
+                             DIP { DUP } ;
+                             SWAP ;
+                             MEM ;
+                             IF { DIP { DUP } ;
+                                  SWAP ;
+                                  DIG 2 ;
+                                  DUP ;
+                                  DUG 3 ;
+                                  CDR ;
+                                  CAR ;
+                                  CAR ;
+                                  PUSH nat 1 ;
+                                  DIG 5 ;
+                                  DUP ;
+                                  DUG 6 ;
+                                  CDR ;
+                                  CDR ;
+                                  SUB ;
+                                  ABS ;
+                                  DIG 3 ;
+                                  DUP ;
+                                  DUG 4 ;
+                                  SWAP ;
+                                  SOME ;
+                                  SWAP ;
+                                  UPDATE ;
+                                  DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CDR } ;
+                                  PAIR ;
+                                  PAIR ;
+                                  SWAP ;
+                                  PAIR ;
+                                  DIG 2 ;
+                                  DUP ;
+                                  DUG 3 ;
+                                  DIP { DUP } ;
+                                  SWAP ;
+                                  DIP { DROP 2 } }
+                                { DIP { DUP } ; SWAP } ;
+                             DIG 3 ;
+                             DUP ;
+                             DUG 4 ;
+                             CDR ;
+                             DIP { DUP } ;
+                             SWAP ;
+                             PAIR ;
+                             CAR ;
+                             DIP { DROP 4 } } ;
+                      DIG 4 ;
+                      DUP ;
+                      DUG 5 ;
+                      DIG 4 ;
+                      DUP ;
+                      DUG 5 ;
+                      SWAP ;
+                      CAR ;
+                      PAIR ;
+                      DIG 3 ;
+                      DUP ;
+                      DUG 4 ;
+                      SWAP ;
+                      CDR ;
+                      SWAP ;
+                      PAIR ;
+                      DIG 2 ;
+                      DUP ;
+                      DUG 3 ;
+                      SWAP ;
+                      CAR ;
+                      PAIR ;
+                      CAR ;
+                      DIP { DUP } ;
+                      PAIR ;
+                      DIP { DROP 4 } }
+                    { DUP ;
+                      DIG 5 ;
+                      DUP ;
+                      DUG 6 ;
+                      DIG 6 ;
+                      DUP ;
+                      DUG 7 ;
+                      CAR ;
+                      CDR ;
+                      CDR ;
+                      DIG 8 ;
+                      DUP ;
+                      DUG 9 ;
+                      DIG 14 ;
+                      DUP ;
+                      DUG 15 ;
+                      SWAP ;
+                      SOME ;
+                      SWAP ;
+                      UPDATE ;
+                      DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CAR ; SWAP ; CDR ; CAR } ;
+                      SWAP ;
+                      PAIR ;
+                      SWAP ;
+                      PAIR ;
+                      PAIR ;
+                      SWAP ;
+                      CAR ;
+                      PAIR } ;
+                 DUP ;
+                 DIP { DROP 17 } } ;
+             DIP { DROP } }
+           { DIP { DUP } ;
+             SWAP ;
+             DIP { DUP } ;
+             SWAP ;
+             PAIR ;
+             DUP ;
+             CDR ;
+             DIP { DUP } ;
+             SWAP ;
+             CAR ;
+             PACK ;
+             DIP { DUP } ;
+             SWAP ;
+             CAR ;
+             CDR ;
+             CDR ;
+             DIP { DUP } ;
+             SWAP ;
+             GET ;
+             IF_NONE
+               { DIP { DUP } ; SWAP }
+               { DUP ;
+                 PUSH bool False ;
+                 SENDER ;
+                 UPDATE ;
+                 DUP ;
+                 SIZE ;
+                 DIG 2 ;
+                 DUP ;
+                 DUG 3 ;
+                 SIZE ;
+                 COMPARE ;
+                 NEQ ;
+                 IF { DIG 3 ;
+                      DUP ;
+                      DUG 4 ;
+                      DIG 4 ;
+                      DUP ;
+                      DUG 5 ;
+                      CDR ;
+                      CAR ;
+                      CAR ;
+                      PUSH nat 1 ;
+                      DIG 6 ;
+                      DUP ;
+                      DUG 7 ;
+                      CDR ;
+                      CAR ;
+                      CAR ;
+                      SENDER ;
+                      GET ;
+                      IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
+                      SUB ;
+                      ABS ;
+                      SOME ;
+                      SENDER ;
+                      UPDATE ;
+                      DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CDR } ;
+                      PAIR ;
+                      PAIR ;
+                      SWAP ;
+                      PAIR ;
+                      DIG 4 ;
+                      DUP ;
+                      DUG 5 ;
+                      DIP { DUP } ;
+                      SWAP ;
+                      DIP { DROP 2 } }
+                    { DIG 3 ; DUP ; DUG 4 } ;
+                 PUSH nat 0 ;
+                 DIG 2 ;
+                 DUP ;
+                 DUG 3 ;
+                 SIZE ;
+                 COMPARE ;
+                 EQ ;
+                 IF { DUP ;
+                      DIP { DUP } ;
+                      SWAP ;
+                      CAR ;
+                      CDR ;
+                      CDR ;
+                      DIG 5 ;
+                      DUP ;
+                      DUG 6 ;
+                      NONE (set address) ;
+                      SWAP ;
+                      UPDATE ;
+                      DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CAR ; SWAP ; CDR ; CAR } ;
+                      SWAP ;
+                      PAIR ;
+                      SWAP ;
+                      PAIR ;
+                      PAIR ;
+                      DIP { DUP } ;
+                      SWAP ;
+                      DIP { DUP } ;
+                      SWAP ;
+                      DIP { DROP 2 } }
+                    { DUP ;
+                      DIP { DUP } ;
+                      SWAP ;
+                      DIG 2 ;
+                      DUP ;
+                      DUG 3 ;
+                      CAR ;
+                      CDR ;
+                      CDR ;
+                      DIG 4 ;
+                      DUP ;
+                      DUG 5 ;
+                      DIG 7 ;
+                      DUP ;
+                      DUG 8 ;
+                      SWAP ;
+                      SOME ;
+                      SWAP ;
+                      UPDATE ;
+                      DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CAR ; SWAP ; CDR ; CAR } ;
+                      SWAP ;
+                      PAIR ;
+                      SWAP ;
+                      PAIR ;
+                      PAIR ;
+                      DIP { DROP } } ;
+                 DIG 5 ;
+                 DUP ;
+                 DUG 6 ;
+                 DIG 2 ;
+                 DUP ;
+                 DUG 3 ;
+                 DIP { DROP ; DUP } ;
+                 SWAP ;
                  DIP { DROP 5 } } ;
-             DIP { DROP 2 } } } |} ]
+             DUP ;
+             NIL operation ;
+             PAIR ;
+             DIP { DROP 5 } } ;
+         DIP { DROP 2 } } } |} ]
 
 let%expect_test _ =
   run_ligo_good [ "compile-contract" ; contract "vote.mligo" ; "main" ] ;
@@ -831,14 +915,16 @@ let%expect_test _ =
              DIP { DUP } ;
              SWAP ;
              CDR ;
-             DIP 2 { DUP } ;
              DIG 2 ;
+             DUP ;
+             DUG 3 ;
              CAR ;
              CDR ;
              PAIR ;
              PUSH nat 0 ;
-             DIP 3 { DUP } ;
              DIG 3 ;
+             DUP ;
+             DUG 4 ;
              CAR ;
              CAR ;
              PAIR ;
@@ -857,15 +943,18 @@ let%expect_test _ =
              CDR ;
              NOW ;
              SENDER ;
-             DIP 3 { DUP } ;
              DIG 3 ;
+             DUP ;
+             DUG 4 ;
              CAR ;
              IF_LEFT
-               { DIP 3 { DUP } ;
-                 DIG 3 ;
+               { DIG 3 ;
+                 DUP ;
+                 DUG 4 ;
                  PUSH nat 1 ;
-                 DIP 5 { DUP } ;
                  DIG 5 ;
+                 DUP ;
+                 DUG 6 ;
                  CAR ;
                  CAR ;
                  CDR ;
@@ -876,11 +965,13 @@ let%expect_test _ =
                  PAIR ;
                  PAIR ;
                  DIP { DROP } }
-               { DIP 3 { DUP } ;
-                 DIG 3 ;
+               { DIG 3 ;
+                 DUP ;
+                 DUG 4 ;
                  PUSH nat 1 ;
-                 DIP 5 { DUP } ;
                  DIG 5 ;
+                 DUP ;
+                 DUG 6 ;
                  CDR ;
                  CDR ;
                  ADD ;
@@ -895,8 +986,9 @@ let%expect_test _ =
              SWAP ;
              CDR ;
              CAR ;
-             DIP 3 { DUP } ;
              DIG 3 ;
+             DUP ;
+             DUG 4 ;
              PUSH bool True ;
              SWAP ;
              UPDATE ;
@@ -1125,8 +1217,9 @@ ligo: in file "create_contract_var.mligo", line 6, character 35 to line 10, char
              SWAP ;
              CDR ;
              NIL operation ;
-             DIP 2 { DUP } ;
              DIG 2 ;
+             DUP ;
+             DUG 3 ;
              CAR ;
              CONS ;
              PAIR ;
@@ -1223,12 +1316,14 @@ let%expect_test _ =
              PUSH mutez 300000000 ;
              PUSH int 2 ;
              TRANSFER_TOKENS ;
-             DIP 2 { DUP } ;
              DIG 2 ;
+             DUP ;
+             DUG 3 ;
              CDR ;
              NIL operation ;
-             DIP 2 { DUP } ;
              DIG 2 ;
+             DUP ;
+             DUG 3 ;
              CONS ;
              PAIR ;
              DIP { DROP 3 } } } |}] ;
@@ -1242,12 +1337,14 @@ let%expect_test _ =
              PUSH mutez 300000000 ;
              PUSH int 2 ;
              TRANSFER_TOKENS ;
-             DIP 2 { DUP } ;
              DIG 2 ;
+             DUP ;
+             DUG 3 ;
              CDR ;
              NIL operation ;
-             DIP 2 { DUP } ;
              DIG 2 ;
+             DUP ;
+             DUG 3 ;
              CONS ;
              PAIR ;
              DIP { DROP 3 } } } |}] ;
diff --git a/src/passes/12-compiler/compiler_environment.ml b/src/passes/12-compiler/compiler_environment.ml
index 0736593ee..0786def09 100644
--- a/src/passes/12-compiler/compiler_environment.ml
+++ b/src/passes/12-compiler/compiler_environment.ml
@@ -24,8 +24,9 @@ let get : environment -> expression_variable -> michelson result = fun e s ->
       ]
   in
   let aux_dig = fun n -> seq [
-      dipn n i_dup ;
       i_dig n ;
+      i_dup ;
+      i_dug (n + 1) ;
     ]
   in
   let code =