diff --git a/evm/src/cpu/kernel/asm/core/create.asm b/evm/src/cpu/kernel/asm/core/create.asm
index d7e6eed2..5360e616 100644
--- a/evm/src/cpu/kernel/asm/core/create.asm
+++ b/evm/src/cpu/kernel/asm/core/create.asm
@@ -47,10 +47,10 @@ global sys_create2:
     SWAP4
     %stack (salt) -> (salt, sys_create2_got_address)
     // stack: salt, sys_create2_got_address, value, code_offset, code_len, kexit_info
-    DUP4 // code_len
-    DUP4 // code_offset
+    DUP5 // code_len
+    DUP5 // code_offset
     PUSH @SEGMENT_MAIN_MEMORY
-    PUSH 0 // context
+    GET_CONTEXT
     KECCAK_GENERAL
     // stack: hash, salt, sys_create2_got_address, value, code_offset, code_len, kexit_info
     %address
diff --git a/evm/src/cpu/kernel/asm/core/create_addresses.asm b/evm/src/cpu/kernel/asm/core/create_addresses.asm
index 7dd4e889..d72d7e67 100644
--- a/evm/src/cpu/kernel/asm/core/create_addresses.asm
+++ b/evm/src/cpu/kernel/asm/core/create_addresses.asm
@@ -34,15 +34,28 @@ global get_create_address:
 
 // Computes the address for a contract based on the CREATE2 rule, i.e.
 //     address = KEC(0xff || sender || salt || code_hash)[12:]
-//
-// Pre stack: sender, salt, code_hash, retdest
+// Clobbers @SEGMENT_KERNEL_GENERAL.
+// Pre stack: sender, code_hash, salt, retdest
 // Post stack: address
 global get_create2_address:
-    // stack: sender, salt, code_hash, retdest
-    // TODO: Replace with actual implementation.
-    %pop3
-    PUSH 123
+    // stack: sender, code_hash, salt, retdest
+    PUSH 0xff PUSH 0 %mstore_kernel_general
+    %stack (sender, code_hash, salt, retdest) -> (0, @SEGMENT_KERNEL_GENERAL, 1, sender, 20, get_create2_address_contd, salt, code_hash, retdest)
+    %jump(mstore_unpacking)
+get_create2_address_contd:
+    POP
+    %stack (salt, code_hash, retdest) -> (0, @SEGMENT_KERNEL_GENERAL, 21, salt, 32, get_create2_address_contd2, code_hash, retdest)
+    %jump(mstore_unpacking)
+get_create2_address_contd2:
+    POP
+    %stack (code_hash, retdest) -> (0, @SEGMENT_KERNEL_GENERAL, 53, code_hash, 32, get_create2_address_finish, retdest)
+    %jump(mstore_unpacking)
+get_create2_address_finish:
+    POP
+    %stack (retdest) -> (0, @SEGMENT_KERNEL_GENERAL, 0, 85, retdest) // context, segment, offset, len
+    KECCAK_GENERAL
     // stack: address, retdest
+    %mod_const(0x10000000000000000000000000000000000000000) // 2^160
     %observe_new_address
     SWAP1
     JUMP
diff --git a/evm/src/cpu/kernel/asm/memory/metadata.asm b/evm/src/cpu/kernel/asm/memory/metadata.asm
index d891c0d1..1c526c2d 100644
--- a/evm/src/cpu/kernel/asm/memory/metadata.asm
+++ b/evm/src/cpu/kernel/asm/memory/metadata.asm
@@ -201,7 +201,7 @@ global sys_basefee:
     // stack: old_num_words, num_words, kexit_info
     DUP2 DUP2 GT
     // stack: old_num_words > num_words, old_num_words, num_words, kexit_info
-    %jumpi(%%end)
+    %jumpi(%%no_update)
     // stack: old_num_words, num_words, kexit_info
     %memory_cost
     // stack: old_cost, num_words, kexit_info
@@ -214,6 +214,10 @@ global sys_basefee:
     SUB
     // stack: additional_cost, kexit_info
     %charge_gas
+    %jump(%%end)
+%%no_update:
+    // stack: old_num_words, num_words, kexit_info
+    %pop2
 %%end:
     // stack: kexit_info
 %endmacro
diff --git a/evm/src/cpu/kernel/asm/memory/syscalls.asm b/evm/src/cpu/kernel/asm/memory/syscalls.asm
index 11f8054b..86435408 100644
--- a/evm/src/cpu/kernel/asm/memory/syscalls.asm
+++ b/evm/src/cpu/kernel/asm/memory/syscalls.asm
@@ -124,14 +124,14 @@ sys_calldataload_after_mload_packing:
     // stack: kexit_info, dest_offset, offset, size
     DUP4 %num_bytes_to_num_words %mul_const(@GAS_COPY) %add_const(@GAS_VERYLOW) %charge_gas
 
-    %stack (kexit_info, dest_offset, offset, size) -> (dest_offset, size, dest_offset, offset, size, kexit_info)
+    %stack (kexit_info, dest_offset, offset, size) -> (dest_offset, size, kexit_info, dest_offset, offset, size)
     ADD // TODO: check for overflow, see discussion here https://github.com/mir-protocol/plonky2/pull/930/files/a4ea0965d79561c345e2f77836c07949c7e0bc69#r1143630253
-    // stack: expanded_num_bytes, dest_offset, offset, size, kexit_info
+    // stack: expanded_num_bytes, kexit_info, dest_offset, offset, size, kexit_info
     DUP1 %ensure_reasonable_offset
     %update_mem_bytes
 
     GET_CONTEXT
-    %stack (context, dest_offset, offset, size, kexit_info) ->
+    %stack (context, kexit_info, dest_offset, offset, size) ->
         (context, @SEGMENT_MAIN_MEMORY, dest_offset, context, $segment, offset, size, %%after, kexit_info)
     %jump(memcpy)
 %%after:
diff --git a/evm/src/cpu/kernel/tests/core/create_addresses.rs b/evm/src/cpu/kernel/tests/core/create_addresses.rs
index 03d780d8..3f316578 100644
--- a/evm/src/cpu/kernel/tests/core/create_addresses.rs
+++ b/evm/src/cpu/kernel/tests/core/create_addresses.rs
@@ -1,6 +1,9 @@
+use std::str::FromStr;
+
 use anyhow::Result;
-use ethereum_types::U256;
+use ethereum_types::{H256, U256};
 use hex_literal::hex;
+use keccak_hash::keccak;
 
 use crate::cpu::kernel::aggregator::KERNEL;
 use crate::cpu::kernel::interpreter::Interpreter;
@@ -24,22 +27,89 @@ fn test_get_create_address() -> Result<()> {
     Ok(())
 }
 
+struct Create2TestCase {
+    code_hash: H256,
+    salt: U256,
+    sender: U256,
+    expected_addr: U256,
+}
+
+/// Taken from https://eips.ethereum.org/EIPS/eip-1014
+fn create2_test_cases() -> Vec<Create2TestCase> {
+    vec![
+        Create2TestCase {
+            code_hash: keccak(hex!("00")),
+            salt: U256::zero(),
+            sender: U256::zero(),
+            expected_addr: U256::from_str("0x4D1A2e2bB4F88F0250f26Ffff098B0b30B26BF38").unwrap(),
+        },
+        Create2TestCase {
+            code_hash: keccak(hex!("00")),
+            salt: U256::zero(),
+            sender: U256::from_str("0xdeadbeef00000000000000000000000000000000").unwrap(),
+            expected_addr: U256::from_str("0xB928f69Bb1D91Cd65274e3c79d8986362984fDA3").unwrap(),
+        },
+        Create2TestCase {
+            code_hash: keccak(hex!("00")),
+            salt: U256::from_str(
+                "0x000000000000000000000000feed000000000000000000000000000000000000",
+            )
+            .unwrap(),
+            sender: U256::from_str("0xdeadbeef00000000000000000000000000000000").unwrap(),
+            expected_addr: U256::from_str("0xD04116cDd17beBE565EB2422F2497E06cC1C9833").unwrap(),
+        },
+        Create2TestCase {
+            code_hash: keccak(hex!("deadbeef")),
+            salt: U256::zero(),
+            sender: U256::zero(),
+            expected_addr: U256::from_str("0x70f2b2914A2a4b783FaEFb75f459A580616Fcb5e").unwrap(),
+        },
+        Create2TestCase {
+            code_hash: keccak(hex!("deadbeef")),
+            salt: U256::from_str(
+                "0x00000000000000000000000000000000000000000000000000000000cafebabe",
+            )
+            .unwrap(),
+            sender: U256::from_str("0x00000000000000000000000000000000deadbeef").unwrap(),
+            expected_addr: U256::from_str("0x60f3f640a8508fC6a86d45DF051962668E1e8AC7").unwrap(),
+        },
+        Create2TestCase {
+            code_hash: keccak(hex!("deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef")),
+            salt: U256::from_str(
+                "0x00000000000000000000000000000000000000000000000000000000cafebabe",
+            )
+            .unwrap(),
+            sender: U256::from_str("0x00000000000000000000000000000000deadbeef").unwrap(),
+            expected_addr: U256::from_str("0x1d8bfDC5D46DC4f61D6b6115972536eBE6A8854C").unwrap(),
+        },
+        Create2TestCase {
+            code_hash: keccak(hex!("")),
+            salt: U256::zero(),
+            sender: U256::zero(),
+            expected_addr: U256::from_str("0xE33C0C7F7df4809055C3ebA6c09CFe4BaF1BD9e0").unwrap(),
+        },
+    ]
+}
+
 #[test]
 fn test_get_create2_address() -> Result<()> {
     let get_create2_address = KERNEL.global_labels["get_create2_address"];
 
-    // TODO: Replace with real data once we have a real implementation.
     let retaddr = 0xdeadbeefu32.into();
-    let code_hash = 0.into();
-    let salt = 5.into();
-    let sender = 0.into();
-    let expected_addr = 123.into();
 
-    let initial_stack = vec![retaddr, code_hash, salt, sender];
-    let mut interpreter = Interpreter::new_with_kernel(get_create2_address, initial_stack);
-    interpreter.run()?;
+    for Create2TestCase {
+        code_hash,
+        salt,
+        sender,
+        expected_addr,
+    } in create2_test_cases()
+    {
+        let initial_stack = vec![retaddr, salt, U256::from(code_hash.0), sender];
+        let mut interpreter = Interpreter::new_with_kernel(get_create2_address, initial_stack);
+        interpreter.run()?;
 
-    assert_eq!(interpreter.stack(), &[expected_addr]);
+        assert_eq!(interpreter.stack(), &[expected_addr]);
+    }
 
     Ok(())
 }