diff --git a/core/vm/gen/main.go b/core/vm/gen/main.go
index c34b326c99..f5fc034ade 100644
--- a/core/vm/gen/main.go
+++ b/core/vm/gen/main.go
@@ -115,6 +115,10 @@ type generator struct {
 	buf      *bytes.Buffer
 }
 
+// p is the sole writer of the generated file. Every line of output is appended
+// to g.buf through it. The splice helpers (inlineBody, inlineFactoryBody) only
+// build text, which their callers then hand to p.
+//
 // p formats and appends generated Go, like fmt.Fprintf. A template can start on
 // the line after p( and be indented to match its structure. p drops the leading
 // newline and the indent before the closing backtick, and gofmt tidies the rest.
@@ -153,26 +157,84 @@ func parseHandlers(vmDir string) (*token.FileSet, map[string]*ast.FuncDecl) {
 
 var returnRe = regexp.MustCompile(`^(\s*)return\s+([^,]+),\s*(.+)$`)
 
-// inlineBody returns the source of handler's body, rewritten so it can be
-// spliced into the dispatch loop: the `*pc` dereference becomes the loop's `pc`
-// local, and each `return r0, r1` becomes loop control flow. Success
-// (r1 == nil) advances pc and continues, an error sets err and breaks.
+// inlineBody returns a named handler's body, rewritten so it can be spliced
+// into the dispatch loop (see rewriteSplicedBody). The caller emits it with p.
 func (g *generator) inlineBody(handler string) string {
 	fn := g.handlers[handler]
 	if fn == nil {
 		fatalf("no handler %q to inline", handler)
 	}
+	return g.rewriteSplicedBody(g.renderAst(fn.Body.List))
+}
+
+// inlineFactoryBody splices the body of the executionFunc closure that a make*
+// factory returns, substituting the factory's parameters with the per-opcode
+// constants in args (positional, matching the factory signature). This lets
+// closure-built handlers (makePush, makeDup) be derived from their single
+// definition rather than restated in the generator. The caller emits the
+// result with p.
+func (g *generator) inlineFactoryBody(factory string, args ...int) string {
+	fn := g.handlers[factory]
+	if fn == nil {
+		fatalf("no factory %q to inline", factory)
+	}
+	lit := factoryClosure(factory, fn)
+	src := g.renderAst(lit.Body.List)
+	var names []string
+	for _, f := range fn.Type.Params.List {
+		for _, nm := range f.Names {
+			names = append(names, nm.Name)
+		}
+	}
+	if len(names) != len(args) {
+		fatalf("factory %q takes %d params, got %d args", factory, len(names), len(args))
+	}
+	for i, nm := range names {
+		src = regexp.MustCompile(`\b`+nm+`\b`).ReplaceAllString(src, fmt.Sprint(args[i]))
+	}
+	return g.rewriteSplicedBody(src)
+}
+
+// factoryClosure returns the executionFunc literal that a make* factory's body
+// is a single `return func(...) {...}` of.
+func factoryClosure(name string, fn *ast.FuncDecl) *ast.FuncLit {
+	if len(fn.Body.List) != 1 {
+		fatalf("factory %q body is not a single return", name)
+	}
+	ret, ok := fn.Body.List[0].(*ast.ReturnStmt)
+	if !ok || len(ret.Results) != 1 {
+		fatalf("factory %q does not return a single value", name)
+	}
+	lit, ok := ret.Results[0].(*ast.FuncLit)
+	if !ok {
+		fatalf("factory %q does not return a func literal", name)
+	}
+	return lit
+}
+
+// renderAst converts AST statements back to formatted Go source text, the
+// inverse of parsing. It uses the generator's fileset and emits nothing itself
+// (the caller passes the result to p).
+func (g *generator) renderAst(stmts []ast.Stmt) string {
 	var raw bytes.Buffer
 	cfg := printer.Config{Mode: printer.UseSpaces | printer.TabIndent, Tabwidth: 8}
-	for _, stmt := range fn.Body.List {
+	for _, stmt := range stmts {
 		if err := cfg.Fprint(&raw, g.fset, stmt); err != nil {
-			fatalf("print %s body: %v", handler, err)
+			fatalf("print stmt: %v", err)
 		}
 		raw.WriteByte('\n')
 	}
-	src := strings.ReplaceAll(raw.String(), "*pc", "pc")
+	return raw.String()
+}
 
-	var out strings.Builder
+// rewriteSplicedBody rewrites a printed handler body so it runs inside the
+// dispatch loop: the `*pc` dereference becomes the loop's `pc` local, and each
+// `return r0, r1` becomes loop control flow. Success (r1 == nil) advances pc
+// and continues, an error sets err and breaks. Stack helpers are then expanded.
+func (g *generator) rewriteSplicedBody(src string) string {
+	src = strings.ReplaceAll(src, "*pc", "pc")
+
+	var out bytes.Buffer
 	for _, line := range strings.Split(src, "\n") {
 		if m := returnRe.FindStringSubmatch(line); m != nil {
 			indent, r0, r1 := m[1], strings.TrimSpace(m[2]), strings.TrimSpace(m[3])
@@ -214,6 +276,7 @@ var (
 	pop2Re      = regexp.MustCompile(`(?m)^(\s*)(\w+), (\w+) := scope\.Stack\.pop2\(\)$`)
 	getAssignRe = regexp.MustCompile(`(?m)^(\s*)(\w+) := scope\.Stack\.get\(\)$`)
 	getCallRe   = regexp.MustCompile(`(?m)^(\s*)scope\.Stack\.get\(\)\.(\w+)\((.*)\)$`)
+	dupRe       = regexp.MustCompile(`(?m)^(\s*)scope\.Stack\.dup\((\d+)\)$`)
 	varBlockRe  = regexp.MustCompile(`(?ms)^(\s*)var \(\n(.*?)\n\s*\)$`)
 	varMemberRe = regexp.MustCompile(`(?m)^\s*([\w, ]+?)\s*= (.*)$`)
 )
@@ -239,6 +302,8 @@ func expandStackHelpers(src string) string {
 		"${1}$2 := &stack.inner.data[stack.inner.top]\n${1}stack.inner.top++\n${1}stack.size++")
 	src = getCallRe.ReplaceAllString(src,
 		"${1}stack.inner.data[stack.inner.top].$2($3)\n${1}stack.inner.top++\n${1}stack.size++")
+	src = dupRe.ReplaceAllString(src,
+		"${1}stack.inner.data[stack.bottom+stack.size] = stack.inner.data[stack.bottom+stack.size-$2]\n${1}stack.size++\n${1}stack.inner.top++")
 	return src
 }
 
@@ -363,16 +428,11 @@ func (g *generator) emitWork(code byte) {
 	}
 
 	switch {
-	case code >= 0x62 && code <= 0x7f: // PUSH3-PUSH32: inline makePush(n,n)
-		g.emitPushFixed(int(code) - 0x5f)
-	case code >= 0x80 && code <= 0x8f: // DUP1-DUP16: the dup body, emitted raw
-		g.p(`
-			stack.inner.data[stack.bottom+stack.size] = stack.inner.data[stack.bottom+stack.size-%d]
-			stack.size++
-			stack.inner.top++
-			pc++
-			continue mainLoop
-		`, int(code)-0x7f)
+	case code >= 0x62 && code <= 0x7f: // PUSH3-PUSH32: splice makePush(n, n)
+		n := int(code) - 0x5f
+		g.p("%s", g.inlineFactoryBody("makePush", n, n))
+	case code >= 0x80 && code <= 0x8f: // DUP1-DUP16: splice makeDup(n)
+		g.p("%s", g.inlineFactoryBody("makeDup", int(code)-0x7f))
 	case code >= 0x90 && code <= 0x9f: // SWAP1-SWAP16: the swap body, emitted raw
 		n := int(code) - 0x8f
 		g.p(`
@@ -385,25 +445,6 @@ func (g *generator) emitWork(code byte) {
 	}
 }
 
-// emitPushFixed inlines makePush(n, n) for PUSH<n> (n = 3..32).
-func (g *generator) emitPushFixed(n int) {
-	g.p(`
-		codeLen := len(scope.Contract.Code)
-		start := min(codeLen, int(pc+1))
-		end := min(codeLen, start+%d)
-		a := &stack.inner.data[stack.inner.top]
-		stack.inner.top++
-		stack.size++
-		a.SetBytes(scope.Contract.Code[start:end])
-		if missing := %d - (end - start); missing > 0 {
-			a.Lsh(a, uint(8*missing))
-		}
-		pc += %d
-		pc++
-		continue mainLoop
-	`, n, n, n)
-}
-
 func (g *generator) emitInlineCase(code byte) {
 	m := g.meta[code]
 	g.p("case %s:\n", m.name)
diff --git a/core/vm/interp_gen.go b/core/vm/interp_gen.go
index ab440cb453..08edb5a04e 100644
--- a/core/vm/interp_gen.go
+++ b/core/vm/interp_gen.go
@@ -827,9 +827,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+3)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+3)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -840,6 +842,7 @@ mainLoop:
 			pc += 3
 			pc++
 			continue mainLoop
+
 		case PUSH4:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -856,9 +859,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+4)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+4)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -869,6 +874,7 @@ mainLoop:
 			pc += 4
 			pc++
 			continue mainLoop
+
 		case PUSH5:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -885,9 +891,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+5)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+5)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -898,6 +906,7 @@ mainLoop:
 			pc += 5
 			pc++
 			continue mainLoop
+
 		case PUSH6:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -914,9 +923,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+6)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+6)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -927,6 +938,7 @@ mainLoop:
 			pc += 6
 			pc++
 			continue mainLoop
+
 		case PUSH7:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -943,9 +955,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+7)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+7)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -956,6 +970,7 @@ mainLoop:
 			pc += 7
 			pc++
 			continue mainLoop
+
 		case PUSH8:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -972,9 +987,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+8)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+8)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -985,6 +1002,7 @@ mainLoop:
 			pc += 8
 			pc++
 			continue mainLoop
+
 		case PUSH9:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1001,9 +1019,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+9)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+9)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1014,6 +1034,7 @@ mainLoop:
 			pc += 9
 			pc++
 			continue mainLoop
+
 		case PUSH10:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1030,9 +1051,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+10)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+10)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1043,6 +1066,7 @@ mainLoop:
 			pc += 10
 			pc++
 			continue mainLoop
+
 		case PUSH11:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1059,9 +1083,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+11)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+11)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1072,6 +1098,7 @@ mainLoop:
 			pc += 11
 			pc++
 			continue mainLoop
+
 		case PUSH12:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1088,9 +1115,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+12)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+12)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1101,6 +1130,7 @@ mainLoop:
 			pc += 12
 			pc++
 			continue mainLoop
+
 		case PUSH13:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1117,9 +1147,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+13)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+13)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1130,6 +1162,7 @@ mainLoop:
 			pc += 13
 			pc++
 			continue mainLoop
+
 		case PUSH14:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1146,9 +1179,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+14)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+14)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1159,6 +1194,7 @@ mainLoop:
 			pc += 14
 			pc++
 			continue mainLoop
+
 		case PUSH15:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1175,9 +1211,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+15)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+15)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1188,6 +1226,7 @@ mainLoop:
 			pc += 15
 			pc++
 			continue mainLoop
+
 		case PUSH16:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1204,9 +1243,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+16)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+16)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1217,6 +1258,7 @@ mainLoop:
 			pc += 16
 			pc++
 			continue mainLoop
+
 		case PUSH17:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1233,9 +1275,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+17)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+17)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1246,6 +1290,7 @@ mainLoop:
 			pc += 17
 			pc++
 			continue mainLoop
+
 		case PUSH18:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1262,9 +1307,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+18)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+18)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1275,6 +1322,7 @@ mainLoop:
 			pc += 18
 			pc++
 			continue mainLoop
+
 		case PUSH19:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1291,9 +1339,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+19)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+19)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1304,6 +1354,7 @@ mainLoop:
 			pc += 19
 			pc++
 			continue mainLoop
+
 		case PUSH20:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1320,9 +1371,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+20)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+20)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1333,6 +1386,7 @@ mainLoop:
 			pc += 20
 			pc++
 			continue mainLoop
+
 		case PUSH21:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1349,9 +1403,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+21)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+21)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1362,6 +1418,7 @@ mainLoop:
 			pc += 21
 			pc++
 			continue mainLoop
+
 		case PUSH22:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1378,9 +1435,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+22)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+22)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1391,6 +1450,7 @@ mainLoop:
 			pc += 22
 			pc++
 			continue mainLoop
+
 		case PUSH23:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1407,9 +1467,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+23)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+23)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1420,6 +1482,7 @@ mainLoop:
 			pc += 23
 			pc++
 			continue mainLoop
+
 		case PUSH24:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1436,9 +1499,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+24)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+24)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1449,6 +1514,7 @@ mainLoop:
 			pc += 24
 			pc++
 			continue mainLoop
+
 		case PUSH25:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1465,9 +1531,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+25)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+25)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1478,6 +1546,7 @@ mainLoop:
 			pc += 25
 			pc++
 			continue mainLoop
+
 		case PUSH26:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1494,9 +1563,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+26)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+26)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1507,6 +1578,7 @@ mainLoop:
 			pc += 26
 			pc++
 			continue mainLoop
+
 		case PUSH27:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1523,9 +1595,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+27)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+27)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1536,6 +1610,7 @@ mainLoop:
 			pc += 27
 			pc++
 			continue mainLoop
+
 		case PUSH28:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1552,9 +1627,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+28)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+28)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1565,6 +1642,7 @@ mainLoop:
 			pc += 28
 			pc++
 			continue mainLoop
+
 		case PUSH29:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1581,9 +1659,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+29)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+29)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1594,6 +1674,7 @@ mainLoop:
 			pc += 29
 			pc++
 			continue mainLoop
+
 		case PUSH30:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1610,9 +1691,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+30)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+30)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1623,6 +1706,7 @@ mainLoop:
 			pc += 30
 			pc++
 			continue mainLoop
+
 		case PUSH31:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1639,9 +1723,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+31)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+31)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1652,6 +1738,7 @@ mainLoop:
 			pc += 31
 			pc++
 			continue mainLoop
+
 		case PUSH32:
 			if sLen := stack.len(); sLen > 1023 {
 				return nil, &ErrStackOverflow{stackLen: sLen, limit: 1023}
@@ -1668,9 +1755,11 @@ mainLoop:
 				pc++
 				continue mainLoop
 			}
-			codeLen := len(scope.Contract.Code)
-			start := min(codeLen, int(pc+1))
-			end := min(codeLen, start+32)
+			var (
+				codeLen = len(scope.Contract.Code)
+				start   = min(codeLen, int(pc+1))
+				end     = min(codeLen, start+32)
+			)
 			a := &stack.inner.data[stack.inner.top]
 			stack.inner.top++
 			stack.size++
@@ -1681,6 +1770,7 @@ mainLoop:
 			pc += 32
 			pc++
 			continue mainLoop
+
 		case DUP1:
 			if sLen := stack.len(); sLen < 1 {
 				return nil, &ErrStackUnderflow{stackLen: sLen, required: 1}
@@ -1696,6 +1786,7 @@ mainLoop:
 			stack.inner.top++
 			pc++
 			continue mainLoop
+
 		case DUP2:
 			if sLen := stack.len(); sLen < 2 {
 				return nil, &ErrStackUnderflow{stackLen: sLen, required: 2}
@@ -1711,6 +1802,7 @@ mainLoop:
 			stack.inner.top++
 			pc++
 			continue mainLoop
+
 		case DUP3:
 			if sLen := stack.len(); sLen < 3 {
 				return nil, &ErrStackUnderflow{stackLen: sLen, required: 3}
@@ -1726,6 +1818,7 @@ mainLoop:
 			stack.inner.top++
 			pc++
 			continue mainLoop
+
 		case DUP4:
 			if sLen := stack.len(); sLen < 4 {
 				return nil, &ErrStackUnderflow{stackLen: sLen, required: 4}
@@ -1741,6 +1834,7 @@ mainLoop:
 			stack.inner.top++
 			pc++
 			continue mainLoop
+
 		case DUP5:
 			if sLen := stack.len(); sLen < 5 {
 				return nil, &ErrStackUnderflow{stackLen: sLen, required: 5}
@@ -1756,6 +1850,7 @@ mainLoop:
 			stack.inner.top++
 			pc++
 			continue mainLoop
+
 		case DUP6:
 			if sLen := stack.len(); sLen < 6 {
 				return nil, &ErrStackUnderflow{stackLen: sLen, required: 6}
@@ -1771,6 +1866,7 @@ mainLoop:
 			stack.inner.top++
 			pc++
 			continue mainLoop
+
 		case DUP7:
 			if sLen := stack.len(); sLen < 7 {
 				return nil, &ErrStackUnderflow{stackLen: sLen, required: 7}
@@ -1786,6 +1882,7 @@ mainLoop:
 			stack.inner.top++
 			pc++
 			continue mainLoop
+
 		case DUP8:
 			if sLen := stack.len(); sLen < 8 {
 				return nil, &ErrStackUnderflow{stackLen: sLen, required: 8}
@@ -1801,6 +1898,7 @@ mainLoop:
 			stack.inner.top++
 			pc++
 			continue mainLoop
+
 		case DUP9:
 			if sLen := stack.len(); sLen < 9 {
 				return nil, &ErrStackUnderflow{stackLen: sLen, required: 9}
@@ -1816,6 +1914,7 @@ mainLoop:
 			stack.inner.top++
 			pc++
 			continue mainLoop
+
 		case DUP10:
 			if sLen := stack.len(); sLen < 10 {
 				return nil, &ErrStackUnderflow{stackLen: sLen, required: 10}
@@ -1831,6 +1930,7 @@ mainLoop:
 			stack.inner.top++
 			pc++
 			continue mainLoop
+
 		case DUP11:
 			if sLen := stack.len(); sLen < 11 {
 				return nil, &ErrStackUnderflow{stackLen: sLen, required: 11}
@@ -1846,6 +1946,7 @@ mainLoop:
 			stack.inner.top++
 			pc++
 			continue mainLoop
+
 		case DUP12:
 			if sLen := stack.len(); sLen < 12 {
 				return nil, &ErrStackUnderflow{stackLen: sLen, required: 12}
@@ -1861,6 +1962,7 @@ mainLoop:
 			stack.inner.top++
 			pc++
 			continue mainLoop
+
 		case DUP13:
 			if sLen := stack.len(); sLen < 13 {
 				return nil, &ErrStackUnderflow{stackLen: sLen, required: 13}
@@ -1876,6 +1978,7 @@ mainLoop:
 			stack.inner.top++
 			pc++
 			continue mainLoop
+
 		case DUP14:
 			if sLen := stack.len(); sLen < 14 {
 				return nil, &ErrStackUnderflow{stackLen: sLen, required: 14}
@@ -1891,6 +1994,7 @@ mainLoop:
 			stack.inner.top++
 			pc++
 			continue mainLoop
+
 		case DUP15:
 			if sLen := stack.len(); sLen < 15 {
 				return nil, &ErrStackUnderflow{stackLen: sLen, required: 15}
@@ -1906,6 +2010,7 @@ mainLoop:
 			stack.inner.top++
 			pc++
 			continue mainLoop
+
 		case DUP16:
 			if sLen := stack.len(); sLen < 16 {
 				return nil, &ErrStackUnderflow{stackLen: sLen, required: 16}
@@ -1921,6 +2026,7 @@ mainLoop:
 			stack.inner.top++
 			pc++
 			continue mainLoop
+
 		case SWAP1:
 			if sLen := stack.len(); sLen < 2 {
 				return nil, &ErrStackUnderflow{stackLen: sLen, required: 2}