instructions.go

package vm

import (
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"strconv"
	"sync"
	"time"

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/params"
	"github.com/holiman/uint256"
	"golang.org/x/crypto/sha3"
)

// bock number, opcode_name, execution time , state bloat
type dataOP struct {
	B int    `json:"b"`
	O string `json:"o"`
	E int    `json:"e"`
	L uint   `json:"l"`
}

type data_ex struct {
	B uint64 `json:"b"`
	T uint   `json:"t"`
}

var m sync.Mutex

var siz uint = 0 // current siz of chain data

var min_prev int = -1 // prev value of m(minutes)

var tem int = 0 // to check if file is open

var arr1 [1000000]uint //for block execution time
var arr2 [1000000]uint
var arr3 [1000000]uint

var arr_op1 [1000000]uint //for total number of opcodes
var arr_op2 [1000000]uint
var arr_op3 [1000000]uint

var ele_map = make(map[string]uint) // map to store 1 million blocks execution time before converting that to json

var ele_map_op = make(map[string]uint)

var f *os.File

var num_file_write int = 2 // no. of files written to use trigger the next file
var num_file int = 1       // number of file

//extra data
var temp_ex int = 0
var f_ex *os.File

func write_block(bn uint64) {

	//check the condition to write on file again
	tem := bn / 1000000
	k := (tem % 3)
	if tem == uint64(num_file_write) {
		num_file_write = num_file_write + 1

		for i := 0; i < 1000000; i++ {
			id := strconv.Itoa((num_file-1)*1000000 + i)
			if k == 0 {

				ele_map[id] = arr2[i]
				arr2[i] = 0

				ele_map_op[id] = arr_op2[i]
				arr_op2[i] = 0

			} else if k == 1 {
				ele_map[id] = arr3[i]
				arr3[i] = 0

				ele_map_op[id] = arr_op3[i]
				arr_op3[i] = 0
			} else {
				ele_map[id] = arr1[i]
				arr1[i] = 0

				ele_map_op[id] = arr_op1[i]
				arr_op1[i] = 0
			}

		}

		//write in file using map

		//path of file
		pathc := fmt.Sprintf("/home/ubuntu/data-evm-f/block_data/%v.json", num_file)
		pathc_op := fmt.Sprintf("/home/ubuntu/data-evm-f/block_data_op/%v.json", num_file)

		fc, err := os.OpenFile(pathc, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0666)
		if err != nil {
			fmt.Println(err)
		}

		byteArray, _ := json.Marshal(ele_map)
		if _, err := fmt.Fprintf(fc, "%s\n", byteArray); err != nil {
			fmt.Println(err)
		}

		defer fc.Close()

		fc_op, err := os.OpenFile(pathc_op, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0666)
		if err != nil {
			fmt.Println(err)
		}
		//write in file for opcode number
		byteArray, _ = json.Marshal(ele_map_op)
		if _, err := fmt.Fprintf(fc_op, "%s\n", byteArray); err != nil {
			fmt.Println(err)
		}

		defer fc_op.Close()

		//intialise the map again to delete the data
		ele_map = make(map[string]uint)
		ele_map_op = make(map[string]uint)

		num_file = num_file + 1

	}

}

func write_ex(t uint, bn uint64) {
	if temp_ex == 0 {

		f_ex, _ = os.OpenFile("/home/ubuntu/data-evm-f/data_ex/data.json", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0666)

		temp_ex = 1
	}

	tempData := data_ex{B: bn, T: t}
	byteArray, err := json.Marshal(tempData)
	if err != nil {
		fmt.Println(err)
	}

	if _, err := fmt.Fprintf(f_ex, "%s\n", byteArray); err != nil {
		fmt.Println(err)
	}

}

func checkExe(t uint, bn uint64) {

	if bn < (uint64(num_file)-1)*1000000 {
		write_ex(t, bn)
	} else {

		tem := bn / 1000000

		idx := bn % 1000000
		m.Lock()

		if tem%3 == 0 {
			//update the array1

			arr1[idx] = arr1[idx] + t
			arr_op1[idx] = arr_op1[idx] + 1
		} else if tem%3 == 1 {
			//update the array2

			arr2[idx] = arr2[idx] + t
			arr_op2[idx] = arr_op2[idx] + 1

		} else {
			//update the array3

			arr3[idx] = arr3[idx] + t
			arr_op3[idx] = arr_op3[idx] + 1

		}

		if tem == uint64(num_file_write) { //trigger to write in file (1st million gets added in file after 2 million)

			write_block(bn)

		}
		m.Unlock()
	}

}

func writeFile(s string, i int, bnum int) {

	if bnum%10000 == 0 {
		siz = DirSize()
	}

	dt := time.Now()
	d := dt.Format("01-02")
	h := dt.Hour()
	m := dt.Minute() / 5

	if m != min_prev {

		min_prev = m

		if tem != 0 {

			defer f.Close()
		}
		tem = 1

		path := fmt.Sprintf("/home/ubuntu/data-evm-f/data/%s/%v/%v.json", d, h, m)

		f, _ = os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0666)

	}

	tempData := dataOP{B: bnum, O: s, E: i, L: siz}
	byteArray, err := json.Marshal(tempData)
	if err != nil {
		fmt.Println(err)
	}

	if _, err := fmt.Fprintf(f, "%s\n", byteArray); err != nil {
		fmt.Println(err)
	}

}

func DirSize() uint {
	paths := "/home/ubuntu/.bor/data/bor/chaindata"
	var size uint64
	err := filepath.Walk(paths, func(_ string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if !info.IsDir() {
			size += uint64(info.Size())
		}
		return err
	})
	if err != nil {
		fmt.Print(err)
	}
	t := size / 1048576 // returns size in MiB
	return uint(t)
}

func opAdd(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	op := "Add"

	var startTime = time.Now().UnixNano()
	x, y := scope.Stack.pop(), scope.Stack.peek()
	y.Add(&x, y)

	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime

	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)

	writeFile(op, int(dif), int(cbnum))
	return nil, nil
}

func opSub(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	x, y := scope.Stack.pop(), scope.Stack.peek()
	y.Sub(&x, y)
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime

	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)

	return nil, nil
}

func opMul(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	x, y := scope.Stack.pop(), scope.Stack.peek()
	y.Mul(&x, y)

	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opDiv(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	x, y := scope.Stack.pop(), scope.Stack.peek()
	y.Div(&x, y)

	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opSdiv(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	x, y := scope.Stack.pop(), scope.Stack.peek()
	y.SDiv(&x, y)

	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opMod(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	x, y := scope.Stack.pop(), scope.Stack.peek()
	y.Mod(&x, y)
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opSmod(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	x, y := scope.Stack.pop(), scope.Stack.peek()
	y.SMod(&x, y)
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opExp(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	base, exponent := scope.Stack.pop(), scope.Stack.peek()
	exponent.Exp(&base, exponent)
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opSignExtend(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	back, num := scope.Stack.pop(), scope.Stack.peek()
	num.ExtendSign(num, &back)
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime

	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opNot(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	x := scope.Stack.peek()
	x.Not(x)
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opLt(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	x, y := scope.Stack.pop(), scope.Stack.peek()
	if x.Lt(y) {
		y.SetOne()
	} else {
		y.Clear()
	}
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opGt(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	x, y := scope.Stack.pop(), scope.Stack.peek()
	if x.Gt(y) {
		y.SetOne()
	} else {
		y.Clear()
	}
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opSlt(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	x, y := scope.Stack.pop(), scope.Stack.peek()
	if x.Slt(y) {
		y.SetOne()
	} else {
		y.Clear()
	}
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime

	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)

	return nil, nil
}

func opSgt(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	x, y := scope.Stack.pop(), scope.Stack.peek()
	if x.Sgt(y) {
		y.SetOne()
	} else {
		y.Clear()
	}
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opEq(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	x, y := scope.Stack.pop(), scope.Stack.peek()
	if x.Eq(y) {
		y.SetOne()
	} else {
		y.Clear()
	}
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opIszero(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	x := scope.Stack.peek()
	if x.IsZero() {
		x.SetOne()
	} else {
		x.Clear()
	}
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opAnd(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	x, y := scope.Stack.pop(), scope.Stack.peek()
	y.And(&x, y)
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opOr(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	x, y := scope.Stack.pop(), scope.Stack.peek()
	y.Or(&x, y)
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opXor(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	x, y := scope.Stack.pop(), scope.Stack.peek()
	y.Xor(&x, y)
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opByte(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	th, val := scope.Stack.pop(), scope.Stack.peek()
	val.Byte(&th)
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opAddmod(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	x, y, z := scope.Stack.pop(), scope.Stack.pop(), scope.Stack.peek()
	if z.IsZero() {
		z.Clear()
	} else {
		z.AddMod(&x, &y, z)
	}
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opMulmod(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	x, y, z := scope.Stack.pop(), scope.Stack.pop(), scope.Stack.peek()
	z.MulMod(&x, &y, z)
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

// opSHL implements Shift Left
// The SHL instruction (shift left) pops 2 values from the stack, first arg1 and then arg2,
// and pushes on the stack arg2 shifted to the left by arg1 number of bits.
func opSHL(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	// Note, second operand is left in the stack; accumulate result into it, and no need to push it afterwards

	var startTime = time.Now().UnixNano()
	shift, value := scope.Stack.pop(), scope.Stack.peek()
	if shift.LtUint64(256) {
		value.Lsh(value, uint(shift.Uint64()))
	} else {
		value.Clear()
	}
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

// opSHR implements Logical Shift Right
// The SHR instruction (logical shift right) pops 2 values from the stack, first arg1 and then arg2,
// and pushes on the stack arg2 shifted to the right by arg1 number of bits with zero fill.
func opSHR(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	// Note, second operand is left in the stack; accumulate result into it, and no need to push it afterwards

	var startTime = time.Now().UnixNano()
	shift, value := scope.Stack.pop(), scope.Stack.peek()
	if shift.LtUint64(256) {
		value.Rsh(value, uint(shift.Uint64()))
	} else {
		value.Clear()
	}
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

// opSAR implements Arithmetic Shift Right
// The SAR instruction (arithmetic shift right) pops 2 values from the stack, first arg1 and then arg2,
// and pushes on the stack arg2 shifted to the right by arg1 number of bits with sign extension.
func opSAR(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	shift, value := scope.Stack.pop(), scope.Stack.peek()
	if shift.GtUint64(256) {
		if value.Sign() >= 0 {
			value.Clear()
		} else {
			// Max negative shift: all bits set
			value.SetAllOne()
		}
		return nil, nil
	}
	n := uint(shift.Uint64())
	value.SRsh(value, n)
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opSha3(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	op := "Sha3"

	var startTime = time.Now().UnixNano()
	offset, size := scope.Stack.pop(), scope.Stack.peek()
	data := scope.Memory.GetPtr(int64(offset.Uint64()), int64(size.Uint64()))

	if interpreter.hasher == nil {
		interpreter.hasher = sha3.NewLegacyKeccak256().(keccakState)
	} else {
		interpreter.hasher.Reset()
	}
	interpreter.hasher.Write(data)
	interpreter.hasher.Read(interpreter.hasherBuf[:])

	evm := interpreter.evm
	if evm.Config.EnablePreimageRecording {
		evm.StateDB.AddPreimage(interpreter.hasherBuf, data)
	}

	size.SetBytes(interpreter.hasherBuf[:])
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	writeFile(op, int(dif), int(cbnum))
	return nil, nil
}
func opAddress(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	scope.Stack.push(new(uint256.Int).SetBytes(scope.Contract.Address().Bytes()))
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opBalance(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {

	var startTime = time.Now().UnixNano()
	slot := scope.Stack.peek()
	address := common.Address(slot.Bytes20())
	slot.SetFromBig(interpreter.evm.StateDB.GetBalance(address))

	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opOrigin(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	scope.Stack.push(new(uint256.Int).SetBytes(interpreter.evm.Origin.Bytes()))
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}
func opCaller(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	scope.Stack.push(new(uint256.Int).SetBytes(scope.Contract.Caller().Bytes()))
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opCallValue(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	v, _ := uint256.FromBig(scope.Contract.value)
	scope.Stack.push(v)
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opCallDataLoad(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	op := "CallDataLoad"
	var startTime = time.Now().UnixNano()
	x := scope.Stack.peek()
	if offset, overflow := x.Uint64WithOverflow(); !overflow {
		data := getData(scope.Contract.Input, offset, 32)
		x.SetBytes(data)
	} else {
		x.Clear()
	}
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	writeFile(op, int(dif), int(cbnum))
	return nil, nil
}

func opCallDataSize(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	op := "CallDataSize"
	var startTime = time.Now().UnixNano()
	scope.Stack.push(new(uint256.Int).SetUint64(uint64(len(scope.Contract.Input))))
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	writeFile(op, int(dif), int(cbnum))
	return nil, nil
}

func opCallDataCopy(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	op := "CallDataCopy"
	var startTime = time.Now().UnixNano()
	var (
		memOffset  = scope.Stack.pop()
		dataOffset = scope.Stack.pop()
		length     = scope.Stack.pop()
	)
	dataOffset64, overflow := dataOffset.Uint64WithOverflow()
	if overflow {
		dataOffset64 = 0xffffffffffffffff
	}
	// These values are checked for overflow during gas cost calculation
	memOffset64 := memOffset.Uint64()
	length64 := length.Uint64()
	scope.Memory.Set(memOffset64, length64, getData(scope.Contract.Input, dataOffset64, length64))

	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	writeFile(op, int(dif), int(cbnum))

	return nil, nil
}

func opReturnDataSize(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	scope.Stack.push(new(uint256.Int).SetUint64(uint64(len(interpreter.returnData))))
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opReturnDataCopy(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	var (
		memOffset  = scope.Stack.pop()
		dataOffset = scope.Stack.pop()
		length     = scope.Stack.pop()
	)

	offset64, overflow := dataOffset.Uint64WithOverflow()
	if overflow {
		return nil, ErrReturnDataOutOfBounds
	}
	// we can reuse dataOffset now (aliasing it for clarity)
	var end = dataOffset
	end.Add(&dataOffset, &length)
	end64, overflow := end.Uint64WithOverflow()
	if overflow || uint64(len(interpreter.returnData)) < end64 {
		return nil, ErrReturnDataOutOfBounds
	}
	scope.Memory.Set(memOffset.Uint64(), length.Uint64(), interpreter.returnData[offset64:end64])

	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opExtCodeSize(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	slot := scope.Stack.peek()
	slot.SetUint64(uint64(interpreter.evm.StateDB.GetCodeSize(slot.Bytes20())))
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opCodeSize(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	l := new(uint256.Int)
	l.SetUint64(uint64(len(scope.Contract.Code)))
	scope.Stack.push(l)
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opCodeCopy(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	var (
		memOffset  = scope.Stack.pop()
		codeOffset = scope.Stack.pop()
		length     = scope.Stack.pop()
	)
	uint64CodeOffset, overflow := codeOffset.Uint64WithOverflow()
	if overflow {
		uint64CodeOffset = 0xffffffffffffffff
	}
	codeCopy := getData(scope.Contract.Code, uint64CodeOffset, length.Uint64())
	scope.Memory.Set(memOffset.Uint64(), length.Uint64(), codeCopy)

	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)

	return nil, nil
}

func opExtCodeCopy(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	var (
		stack      = scope.Stack
		a          = stack.pop()
		memOffset  = stack.pop()
		codeOffset = stack.pop()
		length     = stack.pop()
	)
	uint64CodeOffset, overflow := codeOffset.Uint64WithOverflow()
	if overflow {
		uint64CodeOffset = 0xffffffffffffffff
	}
	addr := common.Address(a.Bytes20())
	codeCopy := getData(interpreter.evm.StateDB.GetCode(addr), uint64CodeOffset, length.Uint64())
	scope.Memory.Set(memOffset.Uint64(), length.Uint64(), codeCopy)

	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)

	return nil, nil
}

// opExtCodeHash returns the code hash of a specified account.
// There are several cases when the function is called, while we can relay everything
// to `state.GetCodeHash` function to ensure the correctness.
//   (1) Caller tries to get the code hash of a normal contract account, state
// should return the relative code hash and set it as the result.
//
//   (2) Caller tries to get the code hash of a non-existent account, state should
// return common.Hash{} and zero will be set as the result.
//
//   (3) Caller tries to get the code hash for an account without contract code,
// state should return emptyCodeHash(0xc5d246...) as the result.
//
//   (4) Caller tries to get the code hash of a precompiled account, the result
// should be zero or emptyCodeHash.
//
// It is worth noting that in order to avoid unnecessary create and clean,
// all precompile accounts on mainnet have been transferred 1 wei, so the return
// here should be emptyCodeHash.
// If the precompile account is not transferred any amount on a private or
// customized chain, the return value will be zero.
//
//   (5) Caller tries to get the code hash for an account which is marked as suicided
// in the current transaction, the code hash of this account should be returned.
//
//   (6) Caller tries to get the code hash for an account which is marked as deleted,
// this account should be regarded as a non-existent account and zero should be returned.
func opExtCodeHash(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	slot := scope.Stack.peek()
	address := common.Address(slot.Bytes20())
	if interpreter.evm.StateDB.Empty(address) {
		slot.Clear()
	} else {
		slot.SetBytes(interpreter.evm.StateDB.GetCodeHash(address).Bytes())
	}

	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)

	return nil, nil
}

func opGasprice(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	v, _ := uint256.FromBig(interpreter.evm.GasPrice)
	scope.Stack.push(v)
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opBlockhash(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	num := scope.Stack.peek()
	num64, overflow := num.Uint64WithOverflow()
	if overflow {
		num.Clear()
		return nil, nil
	}
	var upper, lower uint64
	upper = interpreter.evm.Context.BlockNumber.Uint64()
	if upper < 257 {
		lower = 0
	} else {
		lower = upper - 256
	}
	if num64 >= lower && num64 < upper {
		num.SetBytes(interpreter.evm.Context.GetHash(num64).Bytes())
	} else {
		num.Clear()
	}
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opCoinbase(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	scope.Stack.push(new(uint256.Int).SetBytes(interpreter.evm.Context.Coinbase.Bytes()))
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opTimestamp(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	v, _ := uint256.FromBig(interpreter.evm.Context.Time)
	scope.Stack.push(v)
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opNumber(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	v, _ := uint256.FromBig(interpreter.evm.Context.BlockNumber)
	scope.Stack.push(v)
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opDifficulty(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	v, _ := uint256.FromBig(interpreter.evm.Context.Difficulty)
	scope.Stack.push(v)
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opGasLimit(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	scope.Stack.push(new(uint256.Int).SetUint64(interpreter.evm.Context.GasLimit))
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opPop(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	scope.Stack.pop()
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opMload(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	op := "Mload"
	var startTime = time.Now().UnixNano()
	v := scope.Stack.peek()
	offset := int64(v.Uint64())
	v.SetBytes(scope.Memory.GetPtr(offset, 32))
	var endTime = time.Now().UnixNano()
	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	writeFile(op, int(dif), int(cbnum))
	return nil, nil
}

func opMstore(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	op := "Mstore"

	var startTime = time.Now().UnixNano()
	// pop value of the stack
	mStart, val := scope.Stack.pop(), scope.Stack.pop()
	scope.Memory.Set32(mStart.Uint64(), &val)
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	writeFile(op, int(dif), int(cbnum))
	return nil, nil
}

func opMstore8(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	off, val := scope.Stack.pop(), scope.Stack.pop()
	scope.Memory.store[off.Uint64()] = byte(val.Uint64())
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opSload(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	op := "Sload"
	var startTime = time.Now().UnixNano()
	loc := scope.Stack.peek()
	hash := common.Hash(loc.Bytes32())
	val := interpreter.evm.StateDB.GetState(scope.Contract.Address(), hash)
	loc.SetBytes(val.Bytes())
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	writeFile(op, int(dif), int(cbnum))
	return nil, nil
}

func opSstore(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	op := "Sstore"
	var startTime = time.Now().UnixNano()
	loc := scope.Stack.pop()
	val := scope.Stack.pop()
	interpreter.evm.StateDB.SetState(scope.Contract.Address(),
		loc.Bytes32(), val.Bytes32())
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	writeFile(op, int(dif), int(cbnum))
	return nil, nil
}

func opJump(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	pos := scope.Stack.pop()
	if !scope.Contract.validJumpdest(&pos) {
		return nil, ErrInvalidJump
	}
	*pc = pos.Uint64()
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opJumpi(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	pos, cond := scope.Stack.pop(), scope.Stack.pop()
	if !cond.IsZero() {
		if !scope.Contract.validJumpdest(&pos) {
			return nil, ErrInvalidJump
		}
		*pc = pos.Uint64()
	} else {
		*pc++
	}
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opJumpdest(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime

	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opPc(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	scope.Stack.push(new(uint256.Int).SetUint64(*pc))
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opMsize(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	scope.Stack.push(new(uint256.Int).SetUint64(uint64(scope.Memory.Len())))
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opGas(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	scope.Stack.push(new(uint256.Int).SetUint64(scope.Contract.Gas))
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opCreate(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	var (
		value        = scope.Stack.pop()
		offset, size = scope.Stack.pop(), scope.Stack.pop()
		input        = scope.Memory.GetCopy(int64(offset.Uint64()), int64(size.Uint64()))
		gas          = scope.Contract.Gas
	)
	if interpreter.evm.chainRules.IsEIP150 {
		gas -= gas / 64
	}
	// reuse size int for stackvalue
	stackvalue := size

	scope.Contract.UseGas(gas)
	//TODO: use uint256.Int instead of converting with toBig()
	var bigVal = big0
	if !value.IsZero() {
		bigVal = value.ToBig()
	}

	res, addr, returnGas, suberr := interpreter.evm.Create(scope.Contract, input, gas, bigVal)
	// Push item on the stack based on the returned error. If the ruleset is
	// homestead we must check for CodeStoreOutOfGasError (homestead only
	// rule) and treat as an error, if the ruleset is frontier we must
	// ignore this error and pretend the operation was successful.
	if interpreter.evm.chainRules.IsHomestead && suberr == ErrCodeStoreOutOfGas {
		stackvalue.Clear()
	} else if suberr != nil && suberr != ErrCodeStoreOutOfGas {
		stackvalue.Clear()
	} else {
		stackvalue.SetBytes(addr.Bytes())
	}
	scope.Stack.push(&stackvalue)
	scope.Contract.Gas += returnGas

	if suberr == ErrExecutionReverted {
		return res, nil
	}

	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opCreate2(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	var (
		endowment    = scope.Stack.pop()
		offset, size = scope.Stack.pop(), scope.Stack.pop()
		salt         = scope.Stack.pop()
		input        = scope.Memory.GetCopy(int64(offset.Uint64()), int64(size.Uint64()))
		gas          = scope.Contract.Gas
	)

	// Apply EIP150
	gas -= gas / 64
	scope.Contract.UseGas(gas)
	// reuse size int for stackvalue
	stackvalue := size
	//TODO: use uint256.Int instead of converting with toBig()
	bigEndowment := big0
	if !endowment.IsZero() {
		bigEndowment = endowment.ToBig()
	}
	res, addr, returnGas, suberr := interpreter.evm.Create2(scope.Contract, input, gas,
		bigEndowment, &salt)
	// Push item on the stack based on the returned error.
	if suberr != nil {
		stackvalue.Clear()
	} else {
		stackvalue.SetBytes(addr.Bytes())
	}
	scope.Stack.push(&stackvalue)
	scope.Contract.Gas += returnGas

	if suberr == ErrExecutionReverted {
		return res, nil
	}

	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opCall(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	op := "Call"
	var startTime = time.Now().UnixNano()
	stack := scope.Stack
	// Pop gas. The actual gas in interpreter.evm.callGasTemp.
	// We can use this as a temporary value
	temp := stack.pop()
	gas := interpreter.evm.callGasTemp
	// Pop other call parameters.
	addr, value, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop()
	toAddr := common.Address(addr.Bytes20())
	// Get the arguments from the memory.
	args := scope.Memory.GetPtr(int64(inOffset.Uint64()), int64(inSize.Uint64()))

	var bigVal = big0
	//TODO: use uint256.Int instead of converting with toBig()
	// By using big0 here, we save an alloc for the most common case (non-ether-transferring contract calls),
	// but it would make more sense to extend the usage of uint256.Int
	if !value.IsZero() {
		gas += params.CallStipend
		bigVal = value.ToBig()
	}

	ret, returnGas, err := interpreter.evm.Call(scope.Contract, toAddr, args, gas, bigVal)

	if err != nil {
		temp.Clear()
	} else {
		temp.SetOne()
	}
	stack.push(&temp)
	if err == nil || err == ErrExecutionReverted {
		ret = common.CopyBytes(ret)
		scope.Memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
	}
	scope.Contract.Gas += returnGas

	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	writeFile(op, int(dif), int(cbnum))
	return ret, nil
}

func opCallCode(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	// Pop gas. The actual gas is in interpreter.evm.callGasTemp.
	stack := scope.Stack
	// We use it as a temporary value
	temp := stack.pop()
	gas := interpreter.evm.callGasTemp
	// Pop other call parameters.
	addr, value, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop()
	toAddr := common.Address(addr.Bytes20())
	// Get arguments from the memory.
	args := scope.Memory.GetPtr(int64(inOffset.Uint64()), int64(inSize.Uint64()))

	//TODO: use uint256.Int instead of converting with toBig()
	var bigVal = big0
	if !value.IsZero() {
		gas += params.CallStipend
		bigVal = value.ToBig()
	}

	ret, returnGas, err := interpreter.evm.CallCode(scope.Contract, toAddr, args, gas, bigVal)
	if err != nil {
		temp.Clear()
	} else {
		temp.SetOne()
	}
	stack.push(&temp)
	if err == nil || err == ErrExecutionReverted {
		ret = common.CopyBytes(ret)
		scope.Memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
	}
	scope.Contract.Gas += returnGas

	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return ret, nil
}

func opDelegateCall(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	op := "DelegateCall"
	var startTime = time.Now().UnixNano()
	stack := scope.Stack
	// Pop gas. The actual gas is in interpreter.evm.callGasTemp.
	// We use it as a temporary value
	temp := stack.pop()
	gas := interpreter.evm.callGasTemp
	// Pop other call parameters.
	addr, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop()
	toAddr := common.Address(addr.Bytes20())
	// Get arguments from the memory.
	args := scope.Memory.GetPtr(int64(inOffset.Uint64()), int64(inSize.Uint64()))

	ret, returnGas, err := interpreter.evm.DelegateCall(scope.Contract, toAddr, args, gas)
	if err != nil {
		temp.Clear()
	} else {
		temp.SetOne()
	}
	stack.push(&temp)
	if err == nil || err == ErrExecutionReverted {
		ret = common.CopyBytes(ret)
		scope.Memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
	}
	scope.Contract.Gas += returnGas

	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	writeFile(op, int(dif), int(cbnum))
	return ret, nil
}

func opStaticCall(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	// Pop gas. The actual gas is in interpreter.evm.callGasTemp.
	stack := scope.Stack
	// We use it as a temporary value
	temp := stack.pop()
	gas := interpreter.evm.callGasTemp
	// Pop other call parameters.
	addr, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop()
	toAddr := common.Address(addr.Bytes20())
	// Get arguments from the memory.
	args := scope.Memory.GetPtr(int64(inOffset.Uint64()), int64(inSize.Uint64()))

	ret, returnGas, err := interpreter.evm.StaticCall(scope.Contract, toAddr, args, gas)
	if err != nil {
		temp.Clear()
	} else {
		temp.SetOne()
	}
	stack.push(&temp)
	if err == nil || err == ErrExecutionReverted {
		ret = common.CopyBytes(ret)
		scope.Memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
	}
	scope.Contract.Gas += returnGas

	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return ret, nil
}

func opReturn(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	offset, size := scope.Stack.pop(), scope.Stack.pop()
	ret := scope.Memory.GetPtr(int64(offset.Uint64()), int64(size.Uint64()))

	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return ret, nil
}

func opRevert(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	offset, size := scope.Stack.pop(), scope.Stack.pop()
	ret := scope.Memory.GetPtr(int64(offset.Uint64()), int64(size.Uint64()))

	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return ret, nil
}

func opStop(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

func opSuicide(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	beneficiary := scope.Stack.pop()
	balance := interpreter.evm.StateDB.GetBalance(scope.Contract.Address())
	interpreter.evm.StateDB.AddBalance(beneficiary.Bytes20(), balance)
	interpreter.evm.StateDB.Suicide(scope.Contract.Address())
	if interpreter.cfg.Debug {
		interpreter.cfg.Tracer.CaptureEnter(SELFDESTRUCT, scope.Contract.Address(), beneficiary.Bytes20(), []byte{}, 0, balance)
		interpreter.cfg.Tracer.CaptureExit([]byte{}, 0, nil)
	}
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

// following functions are used by the instruction jump  table

// make log instruction function
func makeLog(size int) executionFunc {
	return func(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
		var startTime = time.Now().UnixNano()
		topics := make([]common.Hash, size)
		stack := scope.Stack
		mStart, mSize := stack.pop(), stack.pop()
		for i := 0; i < size; i++ {
			addr := stack.pop()
			topics[i] = addr.Bytes32()
		}

		d := scope.Memory.GetCopy(int64(mStart.Uint64()), int64(mSize.Uint64()))
		interpreter.evm.StateDB.AddLog(&types.Log{
			Address: scope.Contract.Address(),
			Topics:  topics,
			Data:    d,
			// This is a non-consensus field, but assigned here because
			// core/state doesn't know the current block number.
			BlockNumber: interpreter.evm.Context.BlockNumber.Uint64(),
		})

		var endTime = time.Now().UnixNano()

		var dif = endTime - startTime
		cbnum := interpreter.evm.Context.BlockNumber.Uint64()

		checkExe(uint(dif), cbnum)
		return nil, nil
	}
}

// opPush1 is a specialized version of pushN
func opPush1(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
	var startTime = time.Now().UnixNano()
	var (
		codeLen = uint64(len(scope.Contract.Code))
		integer = new(uint256.Int)
	)
	*pc += 1
	if *pc < codeLen {
		scope.Stack.push(integer.SetUint64(uint64(scope.Contract.Code[*pc])))
	} else {
		scope.Stack.push(integer.Clear())
	}
	var endTime = time.Now().UnixNano()

	var dif = endTime - startTime
	cbnum := interpreter.evm.Context.BlockNumber.Uint64()

	checkExe(uint(dif), cbnum)
	return nil, nil
}

// make push instruction function
func makePush(size uint64, pushByteSize int) executionFunc {
	return func(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
		var startTime = time.Now().UnixNano()
		codeLen := len(scope.Contract.Code)

		startMin := codeLen
		if int(*pc+1) < startMin {
			startMin = int(*pc + 1)
		}

		endMin := codeLen
		if startMin+pushByteSize < endMin {
			endMin = startMin + pushByteSize
		}

		integer := new(uint256.Int)
		scope.Stack.push(integer.SetBytes(common.RightPadBytes(
			scope.Contract.Code[startMin:endMin], pushByteSize)))

		*pc += size
		var endTime = time.Now().UnixNano()

		var dif = endTime - startTime
		cbnum := interpreter.evm.Context.BlockNumber.Uint64()

		checkExe(uint(dif), cbnum)
		return nil, nil
	}
}

// make dup instruction function
func makeDup(size int64) executionFunc {
	return func(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
		var startTime = time.Now().UnixNano()
		scope.Stack.dup(int(size))
		var endTime = time.Now().UnixNano()

		var dif = endTime - startTime
		cbnum := interpreter.evm.Context.BlockNumber.Uint64()

		checkExe(uint(dif), cbnum)
		return nil, nil
	}
}

// make swap instruction function
func makeSwap(size int64) executionFunc {
	// switch n + 1 otherwise n would be swapped with n

	size++
	return func(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
		var startTime = time.Now().UnixNano()
		scope.Stack.swap(int(size))
		var endTime = time.Now().UnixNano()

		var dif = endTime - startTime
		cbnum := interpreter.evm.Context.BlockNumber.Uint64()

		checkExe(uint(dif), cbnum)
		return nil, nil
	}
}