diff --git a/pkg/vm/memory/memory_value.go b/pkg/vm/memory/memory_value.go
index 38caf0d4..fe9b8513 100644
--- a/pkg/vm/memory/memory_value.go
+++ b/pkg/vm/memory/memory_value.go
@@ -26,17 +26,19 @@ func (address *MemoryAddress) Equal(other *MemoryAddress) bool {
 }
 
 // Adds a memory address and a field element
-func (address *MemoryAddress) Add(lhs *MemoryAddress, rhs *f.Element) (*MemoryAddress, error) {
-	lhsOffset := new(f.Element).SetUint64(lhs.Offset)
-	newOffset := new(f.Element).Add(lhsOffset, rhs)
+func (ma *MemoryAddress) Add(address *MemoryAddress, offset *f.Element) (*MemoryAddress, error) {
+	addressOffset := new(f.Element).SetUint64(address.Offset)
+	resOffset := new(f.Element).Add(addressOffset, offset)
 
-	if !newOffset.IsUint64() {
-		return nil, fmt.Errorf("new offset bigger than uint64: %s", rhs.Text(10))
+	if !resOffset.IsUint64() {
+		return nil, fmt.Errorf("new offset bigger than uint64: %s", resOffset.Text(10))
 	}
 
-	address.SegmentIndex = lhs.SegmentIndex
-	address.Offset = newOffset.Uint64()
-	return address, nil
+	resAddress := &MemoryAddress{
+		SegmentIndex: address.SegmentIndex,
+		Offset:       resOffset.Uint64(),
+	}
+	return resAddress, nil
 }
 
 // Subs from a memory address a felt or another memory address in the same segment
@@ -218,11 +220,9 @@ func (mv *MemoryValue) Add(lhs, rhs *MemoryValue) (*MemoryValue, error) {
 			return nil, errors.New("rhs is not a felt")
 		}
 		mv.address, err = mv.address.Add(lhs.address, rhs.felt)
-		mv.felt = nil // Felt field is set to nil
 	} else {
 		if rhs.IsAddress() {
-			mv.address, err = rhs.address.Add(rhs.address, lhs.felt)
-			mv.felt = nil
+			mv.address, err = mv.address.Add(rhs.address, lhs.felt)
 		} else {
 			mv.felt = mv.felt.Add(lhs.felt, rhs.felt)
 		}
diff --git a/pkg/vm/vm_test.go b/pkg/vm/vm_test.go
index 2957154a..f47c6692 100644
--- a/pkg/vm/vm_test.go
+++ b/pkg/vm/vm_test.go
@@ -348,69 +348,65 @@ func TestInferOperandSub(t *testing.T) {
 	assert.Equal(t, expectedOp0Cell, op0Cell)
 }
 
-func TestComputeRes_Unconstrained(t *testing.T) {
+func TestComputeResUnconstrained(t *testing.T) {
 	vm := defaultVirtualMachine()
 	instruction := Instruction{Res: Unconstrained}
 
-	cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromInt(10)}
-	cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromInt(15)}
-
-	res, err := vm.computeRes(&instruction, cellOp0, cellOp1)
+	res, err := vm.computeRes(&instruction, nil, nil)
 	require.NoError(t, err)
 	assert.Nil(t, res)
 }
 
-func TestComputeRes_Op1(t *testing.T) {
+func TestComputeResOp1(t *testing.T) {
 	vm := defaultVirtualMachine()
 	instruction := Instruction{Res: Op1}
 
-	cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromInt(10)}
 	cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromInt(15)}
 
-	res, err := vm.computeRes(&instruction, cellOp0, cellOp1)
+	res, err := vm.computeRes(&instruction, nil, cellOp1)
 	require.NoError(t, err)
 	expected := mem.MemoryValueFromInt(15)
 	assert.Equal(t, expected, res)
 }
 
-func TestComputeAddRes_AddrToFelt(t *testing.T) {
+func TestComputeAddResAddrToFelt(t *testing.T) {
 	vm := defaultVirtualMachine()
 	instruction := Instruction{Res: AddOperands}
 
-	cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromMemoryAddress(mem.NewMemoryAddress(2, 10))}
+	cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromSegmentAndOffset(2, 10)}
 	cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromInt(15)}
 
 	res, err := vm.computeRes(&instruction, cellOp0, cellOp1)
 	require.NoError(t, err)
-	expected := mem.MemoryValueFromMemoryAddress(mem.NewMemoryAddress(2, 25))
+	expected := mem.MemoryValueFromSegmentAndOffset(2, 25)
 	assert.Equal(t, expected, res)
 }
 
-func TestComputeAddRes_FeltToAddr(t *testing.T) {
+func TestComputeAddResFeltToAddr(t *testing.T) {
 	vm := defaultVirtualMachine()
 	instruction := Instruction{Res: AddOperands}
 
 	cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromInt(15)}
-	cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromMemoryAddress(mem.NewMemoryAddress(2, 15))}
+	cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromSegmentAndOffset(2, 15)}
 
 	res, err := vm.computeRes(&instruction, cellOp0, cellOp1)
 	require.NoError(t, err)
-	expected := mem.MemoryValueFromMemoryAddress(mem.NewMemoryAddress(2, 30))
+	expected := mem.MemoryValueFromSegmentAndOffset(2, 15)
 	assert.Equal(t, expected, res)
 }
 
-func TestComputeAddRes_BothAddrs(t *testing.T) {
+func TestComputeAddResBothAddrs(t *testing.T) {
 	vm := defaultVirtualMachine()
 	instruction := Instruction{Res: AddOperands}
 
-	cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromMemoryAddress(mem.NewMemoryAddress(2, 10))}
-	cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromMemoryAddress(mem.NewMemoryAddress(2, 15))}
+	cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromSegmentAndOffset(2, 10)}
+	cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromSegmentAndOffset(2, 15)}
 
 	_, err := vm.computeRes(&instruction, cellOp0, cellOp1)
 	require.Error(t, err) // Expecting an error since adding two addresses is not allowed
 }
 
-func TestComputeAddRes_BothFelts(t *testing.T) {
+func TestComputeAddResBothFelts(t *testing.T) {
 	vm := defaultVirtualMachine()
 	instruction := Instruction{Res: AddOperands}
 
@@ -424,7 +420,7 @@ func TestComputeAddRes_BothFelts(t *testing.T) {
 }
 
 // Felt should be Positive or Negative. Thus four test cases
-func TestComputeMulRes_PToPFelt(t *testing.T) {
+func TestComputeMulResPosToPosFelt(t *testing.T) {
 	//Positive Felt to Positive Felt compute
 	vm := defaultVirtualMachine()
 	instruction := Instruction{Res: MulOperands}
@@ -437,7 +433,8 @@ func TestComputeMulRes_PToPFelt(t *testing.T) {
 	expected := mem.MemoryValueFromInt(150)
 	assert.Equal(t, expected, res)
 }
-func TestComputeMulRes_NToPFelts(t *testing.T) {
+
+func TestComputeMulResNegToPosFelts(t *testing.T) {
 	vm := defaultVirtualMachine()
 	instruction := Instruction{Res: MulOperands}
 	//Negative to Positive
@@ -450,7 +447,7 @@ func TestComputeMulRes_NToPFelts(t *testing.T) {
 	assert.Equal(t, expected, res)
 }
 
-func TestComputeMulRes_PToNFelt(t *testing.T) {
+func TestComputeMulResPosToNegFelt(t *testing.T) {
 	vm := defaultVirtualMachine()
 	instruction := Instruction{Res: MulOperands}
 	//Positive to Negative
@@ -463,7 +460,7 @@ func TestComputeMulRes_PToNFelt(t *testing.T) {
 	assert.Equal(t, expected, res)
 }
 
-func TestComputeMulRes_NToNFelt(t *testing.T) {
+func TestComputeMulResNegToNegFelt(t *testing.T) {
 	vm := defaultVirtualMachine()
 	instruction := Instruction{Res: MulOperands}
 	//Netagive to Negative
@@ -478,34 +475,34 @@ func TestComputeMulRes_NToNFelt(t *testing.T) {
 
 // Multiplication does not involve addresses
 // three failing cases
-func TestComputeMulRes_AddrToFelt(t *testing.T) {
+func TestComputeMulResAddrToFelt(t *testing.T) {
 	vm := defaultVirtualMachine()
 	instruction := Instruction{Res: MulOperands}
 
-	cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromMemoryAddress(mem.NewMemoryAddress(2, 10))}
+	cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromSegmentAndOffset(2, 10)}
 	cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromInt(15)}
 
 	_, err := vm.computeRes(&instruction, cellOp0, cellOp1)
 	require.Error(t, err) // Expecting an error since multiplying an address with a felt is not allowed
 }
 
-func TestComputeMulRes_FeltToAddr(t *testing.T) {
+func TestComputeMulResFeltToAddr(t *testing.T) {
 	vm := defaultVirtualMachine()
 	instruction := Instruction{Res: MulOperands}
 
 	cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromInt(15)}
-	cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromMemoryAddress(mem.NewMemoryAddress(2, 10))}
+	cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromSegmentAndOffset(2, 10)}
 
 	_, err := vm.computeRes(&instruction, cellOp0, cellOp1)
 	require.Error(t, err)
 }
 
-func TestComputeMulRes_BothAddrs(t *testing.T) {
+func TestComputeMulResBothAddrs(t *testing.T) {
 	vm := defaultVirtualMachine()
 	instruction := Instruction{Res: MulOperands}
 
-	cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromMemoryAddress(mem.NewMemoryAddress(2, 10))}
-	cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromMemoryAddress(mem.NewMemoryAddress(2, 15))}
+	cellOp0 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromSegmentAndOffset(2, 10)}
+	cellOp1 := &mem.Cell{Accessed: true, Value: mem.MemoryValueFromSegmentAndOffset(2, 15)}
 
 	_, err := vm.computeRes(&instruction, cellOp0, cellOp1)
 	require.Error(t, err) // Expecting an error since multiplying two addresses is not allowed