diff --git a/Cargo.lock b/Cargo.lock
index 4c1f38447..b9369f5f5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1057,6 +1057,7 @@ dependencies = [
  "fe-common2",
  "fe-hir",
  "fe-hir-analysis",
+ "fe-library2",
  "fe-macros",
  "salsa-2022",
 ]
@@ -1142,6 +1143,14 @@ dependencies = [
  "include_dir",
 ]
 
+[[package]]
+name = "fe-library2"
+version = "0.23.0"
+dependencies = [
+ "fe-common2",
+ "include_dir",
+]
+
 [[package]]
 name = "fe-macros"
 version = "0.23.0"
diff --git a/crates/driver2/Cargo.toml b/crates/driver2/Cargo.toml
index 9d4e155a9..9e4ddb3a0 100644
--- a/crates/driver2/Cargo.toml
+++ b/crates/driver2/Cargo.toml
@@ -12,6 +12,7 @@ description = "Provides Fe driver"
 [dependencies]
 salsa = { git = "https://github.com/salsa-rs/salsa", package = "salsa-2022" }
 codespan-reporting = "0.11"
+library2 = { path = "../library2", package = "fe-library2" }
 
 hir = { path = "../hir", package = "fe-hir" }
 common = { path = "../common2", package = "fe-common2" }
diff --git a/crates/driver2/error.out b/crates/driver2/error.out
new file mode 100644
index 000000000..f6c65f81d
--- /dev/null
+++ b/crates/driver2/error.out
@@ -0,0 +1,1578 @@
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+
+running 1 test
+test check_std_lib ... FAILED
+
+failures:
+
+---- check_std_lib stdout ----
+thread 'check_std_lib' panicked at 'error[1-0001]: expected comma after field definition
+   ┌─ src/buf.fe:21:14
+   │
+21 │     cur: u256
+   │              ^ expected comma after field definition
+
+error[1-0001]: expected comma after field definition
+   ┌─ src/buf.fe:22:14
+   │
+22 │     len: u256
+   │              ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+   ┌─ src/buf.fe:24:9
+   │
+24 │     pub fn new(len: u256) -> Self {
+   │         ^^ function definition in struct is not allowed
+
+error[1-0001]: expected comma after field definition
+   ┌─ src/buf.fe:26:6
+   │
+26 │     }
+   │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+   ┌─ src/buf.fe:30:9
+   │
+30 │     pub fn advance(mut self, len: u256) -> u256 {
+   │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+   ┌─ src/buf.fe:30:24
+   │
+30 │     pub fn advance(mut self, len: u256) -> u256 {
+   │                        ^^^^ self is not allowed here
+
+error[1-0001]: expected newline after statement
+   ┌─ src/buf.fe:32:16
+   │
+32 │         assert cur + len < self.len + 1
+   │                ^^^ expected newline after statement
+
+error[1-0001]: expected expression
+   ┌─ src/buf.fe:33:19
+   │
+33 │         self.cur += len
+   │                   ^ expected expression
+
+error[1-0001]: expected comma after field definition
+   ┌─ src/buf.fe:35:6
+   │
+35 │     }
+   │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+   ┌─ src/buf.fe:38:9
+   │
+38 │     pub fn remainder(self) -> u256 {
+   │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+   ┌─ src/buf.fe:38:22
+   │
+38 │     pub fn remainder(self) -> u256 {
+   │                      ^^^^ self is not allowed here
+
+error[1-0001]: expected comma after field definition
+   ┌─ src/buf.fe:45:17
+   │
+45 │     offset: u256
+   │                 ^ expected comma after field definition
+
+error[1-0001]: expected comma after field definition
+   ┌─ src/buf.fe:46:14
+   │
+46 │     len: u256
+   │              ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+   ┌─ src/buf.fe:48:9
+   │
+48 │     pub fn new(len: u256) -> Self {
+   │         ^^ function definition in struct is not allowed
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+   ┌─ src/buf.fe:49:16
+   │
+49 │         unsafe {
+   │                ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+   ┌─ src/buf.fe:49:16
+   │
+49 │         unsafe {
+   │                ^ expected item: but got Some(LBrace)
+
+error[1-0001]: self is not allowed here
+   ┌─ src/buf.fe:62:16
+   │
+62 │     pub fn len(self) -> u256 {
+   │                ^^^^ self is not allowed here
+
+error[1-0001]: self is not allowed here
+   ┌─ src/buf.fe:67:19
+   │
+67 │     pub fn offset(self) -> u256 {
+   │                   ^^^^ self is not allowed here
+
+error[1-0001]: self is not allowed here
+   ┌─ src/buf.fe:72:19
+   │
+72 │     pub fn reader(self) -> MemoryBufferReader {
+   │                   ^^^^ self is not allowed here
+
+error[1-0001]: self is not allowed here
+   ┌─ src/buf.fe:77:23
+   │
+77 │     pub fn writer(mut self) -> MemoryBufferWriter {
+   │                       ^^^^ self is not allowed here
+
+error[1-0001]: expected item: but got Some(RBrace)
+   ┌─ src/buf.fe:80:1
+   │
+80 │ }
+   │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected comma after field definition
+   ┌─ src/buf.fe:84:22
+   │
+84 │     buf: MemoryBuffer
+   │                      ^ expected comma after field definition
+
+error[1-0001]: expected comma after field definition
+   ┌─ src/buf.fe:85:16
+   │
+85 │     cur: Cursor 
+   │                ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+   ┌─ src/buf.fe:88:9
+   │
+88 │     pub fn new(mut buf: MemoryBuffer) -> Self {
+   │         ^^ function definition in struct is not allowed
+
+error[1-0001]: expected comma after field definition
+   ┌─ src/buf.fe:93:6
+   │
+93 │     }
+   │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+   ┌─ src/buf.fe:96:9
+   │
+96 │     pub fn remainder(self) -> u256 {
+   │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+   ┌─ src/buf.fe:96:22
+   │
+96 │     pub fn remainder(self) -> u256 {
+   │                      ^^^^ self is not allowed here
+
+error[1-0001]: expected comma after field definition
+   ┌─ src/buf.fe:98:6
+   │
+98 │     }
+   │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:100:9
+    │
+100 │     pub fn write_offset(mut self, len: u256) -> u256 {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:100:29
+    │
+100 │     pub fn write_offset(mut self, len: u256) -> u256 {
+    │                             ^^^^ self is not allowed here
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:102:6
+    │
+102 │     }
+    │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:104:9
+    │
+104 │     pub fn write_n(mut self, value: u256, len: u256) {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:104:24
+    │
+104 │     pub fn write_n(mut self, value: u256, len: u256) {
+    │                        ^^^^ self is not allowed here
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/buf.fe:107:16
+    │
+107 │         unsafe { evm::mstore(offset, value: shifted_value) }
+    │                ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/buf.fe:107:16
+    │
+107 │         unsafe { evm::mstore(offset, value: shifted_value) }
+    │                ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:108:6
+    │
+108 │     }
+    │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:110:9
+    │
+110 │     pub fn write_buf(mut self, buf: MemoryBuffer) {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:110:26
+    │
+110 │     pub fn write_buf(mut self, buf: MemoryBuffer) {
+    │                          ^^^^ self is not allowed here
+
+error[1-0001]: expected path segment
+    ┌─ src/buf.fe:116:13
+    │
+116 │             if bytes_remaining >= 32 {
+    │             ^^ expected path segment
+
+error[1-0001]: expected newline after statement
+    ┌─ src/buf.fe:116:38
+    │
+116 │             if bytes_remaining >= 32 {
+    │                                      ^ expected newline after statement
+
+error[1-0001]: expected newline after statement
+    ┌─ src/buf.fe:118:15
+    │
+118 │             } else if bytes_remaining == 0 {
+    │               ^^^^ expected newline after statement
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:120:14
+    │
+120 │             } else {
+    │              ^ expected comma after field definition
+
+error[1-0001]: expected ident for the field name
+    ┌─ src/buf.fe:120:15
+    │
+120 │             } else {
+    │               ^^^^ expected ident for the field name
+
+error[1-0001]: unexpected token
+    ┌─ src/buf.fe:120:21
+    │  
+120 │               } else {
+    │ ╭────────────────────^
+121 │ │                 // self.write(value: reader.read_u8())
+    │ ╰^ unexpected token
+
+error[1-0001]: expected `name: type` for the field definition
+    ┌─ src/buf.fe:120:21
+    │  
+120 │               } else {
+    │ ╭────────────────────^
+121 │ │                 // self.write(value: reader.read_u8())
+    │ ╰^ expected `name: type` for the field definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/buf.fe:123:9
+    │
+123 │         }
+    │         ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/buf.fe:124:5
+    │
+124 │     }
+    │     ^ expected item: but got Some(RBrace)
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:126:44
+    │
+126 │     pub fn write<T: MemoryBufferWrite>(mut self, value: T) {
+    │                                            ^^^^ self is not allowed here
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/buf.fe:129:1
+    │
+129 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/buf.fe:132:55
+    │
+132 │     fn write_buf(self, mut writer: MemoryBufferWriter);
+    │                                                       ^ expected newline after item definition
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/buf.fe:138:16
+    │
+138 │         unsafe { evm::mstore(offset, value: self) }
+    │                ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/buf.fe:138:16
+    │
+138 │         unsafe { evm::mstore(offset, value: self) }
+    │                ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/buf.fe:169:16
+    │
+169 │         unsafe { evm::mstore8(offset, value: self) }
+    │                ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/buf.fe:169:16
+    │
+169 │         unsafe { evm::mstore8(offset, value: self) }
+    │                ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:180:22
+    │
+180 │     buf: MemoryBuffer
+    │                      ^ expected comma after field definition
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:181:16
+    │
+181 │     cur: Cursor 
+    │                ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:184:9
+    │
+184 │     pub fn new(buf: MemoryBuffer) -> Self {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:186:6
+    │
+186 │     }
+    │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:189:9
+    │
+189 │     pub fn remainder(self) -> u256 {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:189:22
+    │
+189 │     pub fn remainder(self) -> u256 {
+    │                      ^^^^ self is not allowed here
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:191:6
+    │
+191 │     }
+    │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:193:5
+    │
+193 │     fn read_offset(mut self, len: u256) -> u256 {
+    │     ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:193:24
+    │
+193 │     fn read_offset(mut self, len: u256) -> u256 {
+    │                        ^^^^ self is not allowed here
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:195:6
+    │
+195 │     }
+    │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:197:5
+    │
+197 │     fn read_n(mut self, len: u256) -> u256 {
+    │     ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:197:19
+    │
+197 │     fn read_n(mut self, len: u256) -> u256 {
+    │                   ^^^^ self is not allowed here
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/buf.fe:199:16
+    │
+199 │         unsafe {
+    │                ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/buf.fe:199:16
+    │
+199 │         unsafe {
+    │                ^ expected item: but got Some(LBrace)
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:205:24
+    │
+205 │     pub fn read_u8(mut self) -> u8 {
+    │                        ^^^^ self is not allowed here
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:209:25
+    │
+209 │     pub fn read_u16(mut self) -> u16 {
+    │                         ^^^^ self is not allowed here
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:213:25
+    │
+213 │     pub fn read_u32(mut self) -> u32 {
+    │                         ^^^^ self is not allowed here
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:217:25
+    │
+217 │     pub fn read_u64(mut self) -> u64 {
+    │                         ^^^^ self is not allowed here
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:221:26
+    │
+221 │     pub fn read_u128(mut self) -> u128 {
+    │                          ^^^^ self is not allowed here
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:225:26
+    │
+225 │     pub fn read_u256(mut self) -> u256 {
+    │                          ^^^^ self is not allowed here
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/buf.fe:227:16
+    │
+227 │         unsafe {
+    │                ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/buf.fe:227:16
+    │
+227 │         unsafe {
+    │                ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/buf.fe:231:5
+    │
+231 │     }
+    │     ^ expected item: but got Some(RBrace)
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:233:25
+    │
+233 │     pub fn read_buf(mut self, len: u256) -> MemoryBuffer {
+    │                         ^^^^ self is not allowed here
+
+error[1-0001]: expected path segment
+    ┌─ src/buf.fe:240:13
+    │
+240 │             if bytes_remaining >= 32 {
+    │             ^^ expected path segment
+
+error[1-0001]: expected newline after statement
+    ┌─ src/buf.fe:240:38
+    │
+240 │             if bytes_remaining >= 32 {
+    │                                      ^ expected newline after statement
+
+error[1-0001]: expected newline after statement
+    ┌─ src/buf.fe:242:15
+    │
+242 │             } else if bytes_remaining == 0 {
+    │               ^^^^ expected newline after statement
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/buf.fe:244:15
+    │
+244 │             } else {
+    │               ^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(Ident)
+    ┌─ src/buf.fe:245:17
+    │
+245 │                 writer.write(value: self.read_u8())
+    │                 ^^^^^^ expected item: but got Some(Ident)
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/buf.fe:246:13
+    │
+246 │             }
+    │             ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/buf.fe:247:9
+    │
+247 │         }
+    │         ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected item: but got Some(ReturnKw)
+    ┌─ src/buf.fe:249:9
+    │
+249 │         return buf
+    │         ^^^^^^ expected item: but got Some(ReturnKw)
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/buf.fe:250:5
+    │
+250 │     }
+    │     ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/buf.fe:256:1
+    │
+256 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:269:20
+    │
+269 │     input_len: u256
+    │                    ^ expected comma after field definition
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:270:21
+    │
+270 │     output_len: u256
+    │                     ^ expected comma after field definition
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:271:22
+    │
+271 │     buf: MemoryBuffer
+    │                      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:273:9
+    │
+273 │     pub fn new(input_len: u256, output_len: u256) -> Self {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:278:6
+    │
+278 │     }
+    │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:280:9
+    │
+280 │     pub fn input_len(self) -> u256 {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:280:22
+    │
+280 │     pub fn input_len(self) -> u256 {
+    │                      ^^^^ self is not allowed here
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:282:6
+    │
+282 │     }
+    │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:284:9
+    │
+284 │     pub fn output_len(self) -> u256 {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:284:23
+    │
+284 │     pub fn output_len(self) -> u256 {
+    │                       ^^^^ self is not allowed here
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:286:6
+    │
+286 │     }
+    │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:288:9
+    │
+288 │     pub fn offset(self) -> u256 {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:288:19
+    │
+288 │     pub fn offset(self) -> u256 {
+    │                   ^^^^ self is not allowed here
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:290:6
+    │
+290 │     }
+    │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:292:9
+    │
+292 │     pub fn reader(self) -> MemoryBufferReader {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:292:19
+    │
+292 │     pub fn reader(self) -> MemoryBufferReader {
+    │                   ^^^^ self is not allowed here
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:294:6
+    │
+294 │     }
+    │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:296:9
+    │
+296 │     pub fn writer(mut self) -> MemoryBufferWriter {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:296:23
+    │
+296 │     pub fn writer(mut self) -> MemoryBufferWriter {
+    │                       ^^^^ self is not allowed here
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+   ┌─ src/evm.fe:74:10
+   │
+74 │   unsafe { return __add(x, y) }
+   │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+   ┌─ src/evm.fe:74:10
+   │
+74 │   unsafe { return __add(x, y) }
+   │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+   ┌─ src/evm.fe:74:12
+   │
+74 │   unsafe { return __add(x, y) }
+   │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+   ┌─ src/evm.fe:75:1
+   │
+75 │ }
+   │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+   ┌─ src/evm.fe:78:10
+   │
+78 │   unsafe { return __sub(x, y) }
+   │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+   ┌─ src/evm.fe:78:10
+   │
+78 │   unsafe { return __sub(x, y) }
+   │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+   ┌─ src/evm.fe:78:12
+   │
+78 │   unsafe { return __sub(x, y) }
+   │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+   ┌─ src/evm.fe:79:1
+   │
+79 │ }
+   │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+   ┌─ src/evm.fe:82:10
+   │
+82 │   unsafe { return __mul(x, y) }
+   │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+   ┌─ src/evm.fe:82:10
+   │
+82 │   unsafe { return __mul(x, y) }
+   │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+   ┌─ src/evm.fe:82:12
+   │
+82 │   unsafe { return __mul(x, y) }
+   │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+   ┌─ src/evm.fe:83:1
+   │
+83 │ }
+   │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+   ┌─ src/evm.fe:86:10
+   │
+86 │   unsafe { return __div(x, y) }
+   │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+   ┌─ src/evm.fe:86:10
+   │
+86 │   unsafe { return __div(x, y) }
+   │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+   ┌─ src/evm.fe:86:12
+   │
+86 │   unsafe { return __div(x, y) }
+   │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+   ┌─ src/evm.fe:87:1
+   │
+87 │ }
+   │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+   ┌─ src/evm.fe:90:10
+   │
+90 │   unsafe { return __sdiv(x, y) }
+   │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+   ┌─ src/evm.fe:90:10
+   │
+90 │   unsafe { return __sdiv(x, y) }
+   │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+   ┌─ src/evm.fe:90:12
+   │
+90 │   unsafe { return __sdiv(x, y) }
+   │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+   ┌─ src/evm.fe:91:1
+   │
+91 │ }
+   │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected ident for the function name
+   ┌─ src/evm.fe:93:8
+   │
+93 │ pub fn mod(_ x: u256, _ y: u256) -> u256 {
+   │        ^^^ expected ident for the function name
+
+error[1-0001]: unexpected token
+   ┌─ src/evm.fe:93:8
+   │
+93 │ pub fn mod(_ x: u256, _ y: u256) -> u256 {
+   │        ^^^ unexpected token
+
+error[1-0001]: unexpected token
+   ┌─ src/evm.fe:93:8
+   │
+93 │ pub fn mod(_ x: u256, _ y: u256) -> u256 {
+   │        ^^^ unexpected token
+
+error[1-0001]: expected `(` for the function arguments
+   ┌─ src/evm.fe:93:8
+   │
+93 │ pub fn mod(_ x: u256, _ y: u256) -> u256 {
+   │        ^^^ expected `(` for the function arguments
+
+error[1-0001]: unexpected token
+   ┌─ src/evm.fe:93:8
+   │
+93 │ pub fn mod(_ x: u256, _ y: u256) -> u256 {
+   │        ^^^ unexpected token
+
+error[1-0001]: unexpected token
+   ┌─ src/evm.fe:93:8
+   │
+93 │ pub fn mod(_ x: u256, _ y: u256) -> u256 {
+   │        ^^^ unexpected token
+
+error[1-0001]: unexpected token
+   ┌─ src/evm.fe:93:8
+   │
+93 │ pub fn mod(_ x: u256, _ y: u256) -> u256 {
+   │        ^^^ unexpected token
+
+error[1-0001]: function body is required
+   ┌─ src/evm.fe:93:8
+   │
+93 │ pub fn mod(_ x: u256, _ y: u256) -> u256 {
+   │        ^^^ function body is required
+
+error[1-0001]: expected newline after item definition
+   ┌─ src/evm.fe:93:8
+   │
+93 │ pub fn mod(_ x: u256, _ y: u256) -> u256 {
+   │        ^^^ expected newline after item definition
+
+error[1-0001]: expected identifier for the module name
+   ┌─ src/evm.fe:93:11
+   │
+93 │ pub fn mod(_ x: u256, _ y: u256) -> u256 {
+   │           ^ expected identifier for the module name
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+   ┌─ src/evm.fe:94:10
+   │
+94 │   unsafe { return __mod(x, y) }
+   │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+   ┌─ src/evm.fe:94:10
+   │
+94 │   unsafe { return __mod(x, y) }
+   │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+   ┌─ src/evm.fe:98:10
+   │
+98 │   unsafe { return __smod(x, y) }
+   │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+   ┌─ src/evm.fe:98:10
+   │
+98 │   unsafe { return __smod(x, y) }
+   │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+   ┌─ src/evm.fe:98:12
+   │
+98 │   unsafe { return __smod(x, y) }
+   │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+   ┌─ src/evm.fe:99:1
+   │
+99 │ }
+   │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:102:10
+    │
+102 │   unsafe { return __exp(x, y) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:102:10
+    │
+102 │   unsafe { return __exp(x, y) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:102:12
+    │
+102 │   unsafe { return __exp(x, y) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:103:1
+    │
+103 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:106:10
+    │
+106 │   unsafe { return __addmod(x, y, m) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:106:10
+    │
+106 │   unsafe { return __addmod(x, y, m) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:106:12
+    │
+106 │   unsafe { return __addmod(x, y, m) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:107:1
+    │
+107 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:110:10
+    │
+110 │   unsafe { return __mulmod(x, y, m) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:110:10
+    │
+110 │   unsafe { return __mulmod(x, y, m) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:110:12
+    │
+110 │   unsafe { return __mulmod(x, y, m) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:111:1
+    │
+111 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:114:10
+    │
+114 │   unsafe { return __signextend(i, x) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:114:10
+    │
+114 │   unsafe { return __signextend(i, x) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:114:12
+    │
+114 │   unsafe { return __signextend(i, x) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:115:1
+    │
+115 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:121:10
+    │
+121 │   unsafe { return __lt(x, y) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:121:10
+    │
+121 │   unsafe { return __lt(x, y) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:121:12
+    │
+121 │   unsafe { return __lt(x, y) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:122:1
+    │
+122 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:125:10
+    │
+125 │   unsafe { return __gt(x, y) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:125:10
+    │
+125 │   unsafe { return __gt(x, y) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:125:12
+    │
+125 │   unsafe { return __gt(x, y) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:126:1
+    │
+126 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:129:10
+    │
+129 │   unsafe { return __slt(x, y) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:129:10
+    │
+129 │   unsafe { return __slt(x, y) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:129:12
+    │
+129 │   unsafe { return __slt(x, y) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:130:1
+    │
+130 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:133:10
+    │
+133 │   unsafe { return __sgt(x, y) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:133:10
+    │
+133 │   unsafe { return __sgt(x, y) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:133:12
+    │
+133 │   unsafe { return __sgt(x, y) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:134:1
+    │
+134 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:137:10
+    │
+137 │   unsafe { return __eq(x, y) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:137:10
+    │
+137 │   unsafe { return __eq(x, y) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:137:12
+    │
+137 │   unsafe { return __eq(x, y) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:138:1
+    │
+138 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:141:10
+    │
+141 │   unsafe { return __iszero(x) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:141:10
+    │
+141 │   unsafe { return __iszero(x) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:141:12
+    │
+141 │   unsafe { return __iszero(x) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:142:1
+    │
+142 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:147:10
+    │
+147 │   unsafe { return __and(x, y) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:147:10
+    │
+147 │   unsafe { return __and(x, y) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:147:12
+    │
+147 │   unsafe { return __and(x, y) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:148:1
+    │
+148 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:151:10
+    │
+151 │   unsafe { return __or(x, y) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:151:10
+    │
+151 │   unsafe { return __or(x, y) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:151:12
+    │
+151 │   unsafe { return __or(x, y) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:152:1
+    │
+152 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:155:10
+    │
+155 │   unsafe { return __not(x) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:155:10
+    │
+155 │   unsafe { return __not(x) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:155:12
+    │
+155 │   unsafe { return __not(x) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:156:1
+    │
+156 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:159:10
+    │
+159 │   unsafe { return __xor(x, y) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:159:10
+    │
+159 │   unsafe { return __xor(x, y) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:159:12
+    │
+159 │   unsafe { return __xor(x, y) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:160:1
+    │
+160 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:163:10
+    │
+163 │   unsafe { return __byte(offset, value) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:163:10
+    │
+163 │   unsafe { return __byte(offset, value) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:163:12
+    │
+163 │   unsafe { return __byte(offset, value) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:164:1
+    │
+164 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:167:10
+    │
+167 │   unsafe { return __shl(bits, value) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:167:10
+    │
+167 │   unsafe { return __shl(bits, value) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:167:12
+    │
+167 │   unsafe { return __shl(bits, value) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:168:1
+    │
+168 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:171:10
+    │
+171 │   unsafe { return __shr(bits, value) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:171:10
+    │
+171 │   unsafe { return __shr(bits, value) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:171:12
+    │
+171 │   unsafe { return __shr(bits, value) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:172:1
+    │
+172 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:175:10
+    │
+175 │   unsafe { return __sar(bits, value) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:175:10
+    │
+175 │   unsafe { return __sar(bits, value) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:175:12
+    │
+175 │   unsafe { return __sar(bits, value) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:176:1
+    │
+176 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:181:10
+    │
+181 │    unsafe{ __return(buf.offset(), buf.len()) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:181:10
+    │
+181 │    unsafe{ __return(buf.offset(), buf.len()) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:185:12
+    │
+185 │     unsafe { __revert(buf.offset(), buf.len()) }
+    │            ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:185:12
+    │
+185 │     unsafe { __revert(buf.offset(), buf.len()) }
+    │            ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:244:11
+    │
+244 │    unsafe { __calldatacopy(buf.offset(), f, buf.len()) }
+    │           ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:244:11
+    │
+244 │    unsafe { __calldatacopy(buf.offset(), f, buf.len()) }
+    │           ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:276:11
+    │
+276 │    unsafe { return __keccak256(buf.offset(), buf.len()) }
+    │           ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:276:11
+    │
+276 │    unsafe { return __keccak256(buf.offset(), buf.len()) }
+    │           ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:276:13
+    │
+276 │    unsafe { return __keccak256(buf.offset(), buf.len()) }
+    │             ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:277:1
+    │
+277 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:283:12
+    │
+283 │     unsafe { return address(__create(v, buf.offset(), buf.len())) }
+    │            ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:283:12
+    │
+283 │     unsafe { return address(__create(v, buf.offset(), buf.len())) }
+    │            ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:283:14
+    │
+283 │     unsafe { return address(__create(v, buf.offset(), buf.len())) }
+    │              ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:284:1
+    │
+284 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:287:12
+    │
+287 │     unsafe { return address(__create2(v, buf.offset(), buf.len(), s)) }
+    │            ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:287:12
+    │
+287 │     unsafe { return address(__create2(v, buf.offset(), buf.len(), s)) }
+    │            ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:287:14
+    │
+287 │     unsafe { return address(__create2(v, buf.offset(), buf.len(), s)) }
+    │              ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:288:1
+    │
+288 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:292:9
+    │
+292 │   unsafe{ return __call(gas, u256(addr), value, buf.offset(), buf.input_len(), buf.offset(), buf.output_len()) == 1 }
+    │         ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:292:9
+    │
+292 │   unsafe{ return __call(gas, u256(addr), value, buf.offset(), buf.input_len(), buf.offset(), buf.output_len()) == 1 }
+    │         ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:292:11
+    │
+292 │   unsafe{ return __call(gas, u256(addr), value, buf.offset(), buf.input_len(), buf.offset(), buf.output_len()) == 1 }
+    │           ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:293:1
+    │
+293 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:310:12
+    │
+310 │     unsafe { return __log0(buf.offset(), buf.len()) }
+    │            ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:310:12
+    │
+310 │     unsafe { return __log0(buf.offset(), buf.len()) }
+    │            ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:310:14
+    │
+310 │     unsafe { return __log0(buf.offset(), buf.len()) }
+    │              ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:311:1
+    │
+311 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:314:12
+    │
+314 │     unsafe { return __log1(buf.offset(), buf.len(), t1) }
+    │            ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:314:12
+    │
+314 │     unsafe { return __log1(buf.offset(), buf.len(), t1) }
+    │            ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:314:14
+    │
+314 │     unsafe { return __log1(buf.offset(), buf.len(), t1) }
+    │              ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:315:1
+    │
+315 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:318:12
+    │
+318 │     unsafe { return __log2(buf.offset(), buf.len(), t1, t2) }
+    │            ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:318:12
+    │
+318 │     unsafe { return __log2(buf.offset(), buf.len(), t1, t2) }
+    │            ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:318:14
+    │
+318 │     unsafe { return __log2(buf.offset(), buf.len(), t1, t2) }
+    │              ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:319:1
+    │
+319 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:322:12
+    │
+322 │     unsafe { return __log3(buf.offset(), buf.len(), t1, t2, t3) }
+    │            ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:322:12
+    │
+322 │     unsafe { return __log3(buf.offset(), buf.len(), t1, t2, t3) }
+    │            ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:322:14
+    │
+322 │     unsafe { return __log3(buf.offset(), buf.len(), t1, t2, t3) }
+    │              ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:323:1
+    │
+323 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:326:12
+    │
+326 │     unsafe { return __log4(buf.offset(), buf.len(), t1, t2, t3, t4) }
+    │            ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:326:12
+    │
+326 │     unsafe { return __log4(buf.offset(), buf.len(), t1, t2, t3, t4) }
+    │            ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:326:14
+    │
+326 │     unsafe { return __log4(buf.offset(), buf.len(), t1, t2, t3, t4) }
+    │              ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:327:1
+    │
+327 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[2-0002]: `math` is not found
+  ┌─ src/buf.fe:2:12
+  │
+2 │ use ingot::math
+  │            ^^^^ `math` is not found
+
+', crates/driver2/tests/std_lib.rs:13:9
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+
+
+failures:
+    check_std_lib
+
+test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.20s
+
diff --git a/crates/driver2/errors b/crates/driver2/errors
new file mode 100644
index 000000000..f6c65f81d
--- /dev/null
+++ b/crates/driver2/errors
@@ -0,0 +1,1578 @@
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+
+running 1 test
+test check_std_lib ... FAILED
+
+failures:
+
+---- check_std_lib stdout ----
+thread 'check_std_lib' panicked at 'error[1-0001]: expected comma after field definition
+   ┌─ src/buf.fe:21:14
+   │
+21 │     cur: u256
+   │              ^ expected comma after field definition
+
+error[1-0001]: expected comma after field definition
+   ┌─ src/buf.fe:22:14
+   │
+22 │     len: u256
+   │              ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+   ┌─ src/buf.fe:24:9
+   │
+24 │     pub fn new(len: u256) -> Self {
+   │         ^^ function definition in struct is not allowed
+
+error[1-0001]: expected comma after field definition
+   ┌─ src/buf.fe:26:6
+   │
+26 │     }
+   │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+   ┌─ src/buf.fe:30:9
+   │
+30 │     pub fn advance(mut self, len: u256) -> u256 {
+   │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+   ┌─ src/buf.fe:30:24
+   │
+30 │     pub fn advance(mut self, len: u256) -> u256 {
+   │                        ^^^^ self is not allowed here
+
+error[1-0001]: expected newline after statement
+   ┌─ src/buf.fe:32:16
+   │
+32 │         assert cur + len < self.len + 1
+   │                ^^^ expected newline after statement
+
+error[1-0001]: expected expression
+   ┌─ src/buf.fe:33:19
+   │
+33 │         self.cur += len
+   │                   ^ expected expression
+
+error[1-0001]: expected comma after field definition
+   ┌─ src/buf.fe:35:6
+   │
+35 │     }
+   │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+   ┌─ src/buf.fe:38:9
+   │
+38 │     pub fn remainder(self) -> u256 {
+   │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+   ┌─ src/buf.fe:38:22
+   │
+38 │     pub fn remainder(self) -> u256 {
+   │                      ^^^^ self is not allowed here
+
+error[1-0001]: expected comma after field definition
+   ┌─ src/buf.fe:45:17
+   │
+45 │     offset: u256
+   │                 ^ expected comma after field definition
+
+error[1-0001]: expected comma after field definition
+   ┌─ src/buf.fe:46:14
+   │
+46 │     len: u256
+   │              ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+   ┌─ src/buf.fe:48:9
+   │
+48 │     pub fn new(len: u256) -> Self {
+   │         ^^ function definition in struct is not allowed
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+   ┌─ src/buf.fe:49:16
+   │
+49 │         unsafe {
+   │                ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+   ┌─ src/buf.fe:49:16
+   │
+49 │         unsafe {
+   │                ^ expected item: but got Some(LBrace)
+
+error[1-0001]: self is not allowed here
+   ┌─ src/buf.fe:62:16
+   │
+62 │     pub fn len(self) -> u256 {
+   │                ^^^^ self is not allowed here
+
+error[1-0001]: self is not allowed here
+   ┌─ src/buf.fe:67:19
+   │
+67 │     pub fn offset(self) -> u256 {
+   │                   ^^^^ self is not allowed here
+
+error[1-0001]: self is not allowed here
+   ┌─ src/buf.fe:72:19
+   │
+72 │     pub fn reader(self) -> MemoryBufferReader {
+   │                   ^^^^ self is not allowed here
+
+error[1-0001]: self is not allowed here
+   ┌─ src/buf.fe:77:23
+   │
+77 │     pub fn writer(mut self) -> MemoryBufferWriter {
+   │                       ^^^^ self is not allowed here
+
+error[1-0001]: expected item: but got Some(RBrace)
+   ┌─ src/buf.fe:80:1
+   │
+80 │ }
+   │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected comma after field definition
+   ┌─ src/buf.fe:84:22
+   │
+84 │     buf: MemoryBuffer
+   │                      ^ expected comma after field definition
+
+error[1-0001]: expected comma after field definition
+   ┌─ src/buf.fe:85:16
+   │
+85 │     cur: Cursor 
+   │                ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+   ┌─ src/buf.fe:88:9
+   │
+88 │     pub fn new(mut buf: MemoryBuffer) -> Self {
+   │         ^^ function definition in struct is not allowed
+
+error[1-0001]: expected comma after field definition
+   ┌─ src/buf.fe:93:6
+   │
+93 │     }
+   │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+   ┌─ src/buf.fe:96:9
+   │
+96 │     pub fn remainder(self) -> u256 {
+   │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+   ┌─ src/buf.fe:96:22
+   │
+96 │     pub fn remainder(self) -> u256 {
+   │                      ^^^^ self is not allowed here
+
+error[1-0001]: expected comma after field definition
+   ┌─ src/buf.fe:98:6
+   │
+98 │     }
+   │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:100:9
+    │
+100 │     pub fn write_offset(mut self, len: u256) -> u256 {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:100:29
+    │
+100 │     pub fn write_offset(mut self, len: u256) -> u256 {
+    │                             ^^^^ self is not allowed here
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:102:6
+    │
+102 │     }
+    │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:104:9
+    │
+104 │     pub fn write_n(mut self, value: u256, len: u256) {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:104:24
+    │
+104 │     pub fn write_n(mut self, value: u256, len: u256) {
+    │                        ^^^^ self is not allowed here
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/buf.fe:107:16
+    │
+107 │         unsafe { evm::mstore(offset, value: shifted_value) }
+    │                ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/buf.fe:107:16
+    │
+107 │         unsafe { evm::mstore(offset, value: shifted_value) }
+    │                ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:108:6
+    │
+108 │     }
+    │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:110:9
+    │
+110 │     pub fn write_buf(mut self, buf: MemoryBuffer) {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:110:26
+    │
+110 │     pub fn write_buf(mut self, buf: MemoryBuffer) {
+    │                          ^^^^ self is not allowed here
+
+error[1-0001]: expected path segment
+    ┌─ src/buf.fe:116:13
+    │
+116 │             if bytes_remaining >= 32 {
+    │             ^^ expected path segment
+
+error[1-0001]: expected newline after statement
+    ┌─ src/buf.fe:116:38
+    │
+116 │             if bytes_remaining >= 32 {
+    │                                      ^ expected newline after statement
+
+error[1-0001]: expected newline after statement
+    ┌─ src/buf.fe:118:15
+    │
+118 │             } else if bytes_remaining == 0 {
+    │               ^^^^ expected newline after statement
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:120:14
+    │
+120 │             } else {
+    │              ^ expected comma after field definition
+
+error[1-0001]: expected ident for the field name
+    ┌─ src/buf.fe:120:15
+    │
+120 │             } else {
+    │               ^^^^ expected ident for the field name
+
+error[1-0001]: unexpected token
+    ┌─ src/buf.fe:120:21
+    │  
+120 │               } else {
+    │ ╭────────────────────^
+121 │ │                 // self.write(value: reader.read_u8())
+    │ ╰^ unexpected token
+
+error[1-0001]: expected `name: type` for the field definition
+    ┌─ src/buf.fe:120:21
+    │  
+120 │               } else {
+    │ ╭────────────────────^
+121 │ │                 // self.write(value: reader.read_u8())
+    │ ╰^ expected `name: type` for the field definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/buf.fe:123:9
+    │
+123 │         }
+    │         ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/buf.fe:124:5
+    │
+124 │     }
+    │     ^ expected item: but got Some(RBrace)
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:126:44
+    │
+126 │     pub fn write<T: MemoryBufferWrite>(mut self, value: T) {
+    │                                            ^^^^ self is not allowed here
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/buf.fe:129:1
+    │
+129 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/buf.fe:132:55
+    │
+132 │     fn write_buf(self, mut writer: MemoryBufferWriter);
+    │                                                       ^ expected newline after item definition
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/buf.fe:138:16
+    │
+138 │         unsafe { evm::mstore(offset, value: self) }
+    │                ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/buf.fe:138:16
+    │
+138 │         unsafe { evm::mstore(offset, value: self) }
+    │                ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/buf.fe:169:16
+    │
+169 │         unsafe { evm::mstore8(offset, value: self) }
+    │                ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/buf.fe:169:16
+    │
+169 │         unsafe { evm::mstore8(offset, value: self) }
+    │                ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:180:22
+    │
+180 │     buf: MemoryBuffer
+    │                      ^ expected comma after field definition
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:181:16
+    │
+181 │     cur: Cursor 
+    │                ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:184:9
+    │
+184 │     pub fn new(buf: MemoryBuffer) -> Self {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:186:6
+    │
+186 │     }
+    │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:189:9
+    │
+189 │     pub fn remainder(self) -> u256 {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:189:22
+    │
+189 │     pub fn remainder(self) -> u256 {
+    │                      ^^^^ self is not allowed here
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:191:6
+    │
+191 │     }
+    │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:193:5
+    │
+193 │     fn read_offset(mut self, len: u256) -> u256 {
+    │     ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:193:24
+    │
+193 │     fn read_offset(mut self, len: u256) -> u256 {
+    │                        ^^^^ self is not allowed here
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:195:6
+    │
+195 │     }
+    │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:197:5
+    │
+197 │     fn read_n(mut self, len: u256) -> u256 {
+    │     ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:197:19
+    │
+197 │     fn read_n(mut self, len: u256) -> u256 {
+    │                   ^^^^ self is not allowed here
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/buf.fe:199:16
+    │
+199 │         unsafe {
+    │                ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/buf.fe:199:16
+    │
+199 │         unsafe {
+    │                ^ expected item: but got Some(LBrace)
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:205:24
+    │
+205 │     pub fn read_u8(mut self) -> u8 {
+    │                        ^^^^ self is not allowed here
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:209:25
+    │
+209 │     pub fn read_u16(mut self) -> u16 {
+    │                         ^^^^ self is not allowed here
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:213:25
+    │
+213 │     pub fn read_u32(mut self) -> u32 {
+    │                         ^^^^ self is not allowed here
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:217:25
+    │
+217 │     pub fn read_u64(mut self) -> u64 {
+    │                         ^^^^ self is not allowed here
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:221:26
+    │
+221 │     pub fn read_u128(mut self) -> u128 {
+    │                          ^^^^ self is not allowed here
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:225:26
+    │
+225 │     pub fn read_u256(mut self) -> u256 {
+    │                          ^^^^ self is not allowed here
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/buf.fe:227:16
+    │
+227 │         unsafe {
+    │                ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/buf.fe:227:16
+    │
+227 │         unsafe {
+    │                ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/buf.fe:231:5
+    │
+231 │     }
+    │     ^ expected item: but got Some(RBrace)
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:233:25
+    │
+233 │     pub fn read_buf(mut self, len: u256) -> MemoryBuffer {
+    │                         ^^^^ self is not allowed here
+
+error[1-0001]: expected path segment
+    ┌─ src/buf.fe:240:13
+    │
+240 │             if bytes_remaining >= 32 {
+    │             ^^ expected path segment
+
+error[1-0001]: expected newline after statement
+    ┌─ src/buf.fe:240:38
+    │
+240 │             if bytes_remaining >= 32 {
+    │                                      ^ expected newline after statement
+
+error[1-0001]: expected newline after statement
+    ┌─ src/buf.fe:242:15
+    │
+242 │             } else if bytes_remaining == 0 {
+    │               ^^^^ expected newline after statement
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/buf.fe:244:15
+    │
+244 │             } else {
+    │               ^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(Ident)
+    ┌─ src/buf.fe:245:17
+    │
+245 │                 writer.write(value: self.read_u8())
+    │                 ^^^^^^ expected item: but got Some(Ident)
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/buf.fe:246:13
+    │
+246 │             }
+    │             ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/buf.fe:247:9
+    │
+247 │         }
+    │         ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected item: but got Some(ReturnKw)
+    ┌─ src/buf.fe:249:9
+    │
+249 │         return buf
+    │         ^^^^^^ expected item: but got Some(ReturnKw)
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/buf.fe:250:5
+    │
+250 │     }
+    │     ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/buf.fe:256:1
+    │
+256 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:269:20
+    │
+269 │     input_len: u256
+    │                    ^ expected comma after field definition
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:270:21
+    │
+270 │     output_len: u256
+    │                     ^ expected comma after field definition
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:271:22
+    │
+271 │     buf: MemoryBuffer
+    │                      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:273:9
+    │
+273 │     pub fn new(input_len: u256, output_len: u256) -> Self {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:278:6
+    │
+278 │     }
+    │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:280:9
+    │
+280 │     pub fn input_len(self) -> u256 {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:280:22
+    │
+280 │     pub fn input_len(self) -> u256 {
+    │                      ^^^^ self is not allowed here
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:282:6
+    │
+282 │     }
+    │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:284:9
+    │
+284 │     pub fn output_len(self) -> u256 {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:284:23
+    │
+284 │     pub fn output_len(self) -> u256 {
+    │                       ^^^^ self is not allowed here
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:286:6
+    │
+286 │     }
+    │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:288:9
+    │
+288 │     pub fn offset(self) -> u256 {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:288:19
+    │
+288 │     pub fn offset(self) -> u256 {
+    │                   ^^^^ self is not allowed here
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:290:6
+    │
+290 │     }
+    │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:292:9
+    │
+292 │     pub fn reader(self) -> MemoryBufferReader {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:292:19
+    │
+292 │     pub fn reader(self) -> MemoryBufferReader {
+    │                   ^^^^ self is not allowed here
+
+error[1-0001]: expected comma after field definition
+    ┌─ src/buf.fe:294:6
+    │
+294 │     }
+    │      ^ expected comma after field definition
+
+error[1-0001]: function definition in struct is not allowed
+    ┌─ src/buf.fe:296:9
+    │
+296 │     pub fn writer(mut self) -> MemoryBufferWriter {
+    │         ^^ function definition in struct is not allowed
+
+error[1-0001]: self is not allowed here
+    ┌─ src/buf.fe:296:23
+    │
+296 │     pub fn writer(mut self) -> MemoryBufferWriter {
+    │                       ^^^^ self is not allowed here
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+   ┌─ src/evm.fe:74:10
+   │
+74 │   unsafe { return __add(x, y) }
+   │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+   ┌─ src/evm.fe:74:10
+   │
+74 │   unsafe { return __add(x, y) }
+   │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+   ┌─ src/evm.fe:74:12
+   │
+74 │   unsafe { return __add(x, y) }
+   │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+   ┌─ src/evm.fe:75:1
+   │
+75 │ }
+   │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+   ┌─ src/evm.fe:78:10
+   │
+78 │   unsafe { return __sub(x, y) }
+   │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+   ┌─ src/evm.fe:78:10
+   │
+78 │   unsafe { return __sub(x, y) }
+   │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+   ┌─ src/evm.fe:78:12
+   │
+78 │   unsafe { return __sub(x, y) }
+   │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+   ┌─ src/evm.fe:79:1
+   │
+79 │ }
+   │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+   ┌─ src/evm.fe:82:10
+   │
+82 │   unsafe { return __mul(x, y) }
+   │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+   ┌─ src/evm.fe:82:10
+   │
+82 │   unsafe { return __mul(x, y) }
+   │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+   ┌─ src/evm.fe:82:12
+   │
+82 │   unsafe { return __mul(x, y) }
+   │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+   ┌─ src/evm.fe:83:1
+   │
+83 │ }
+   │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+   ┌─ src/evm.fe:86:10
+   │
+86 │   unsafe { return __div(x, y) }
+   │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+   ┌─ src/evm.fe:86:10
+   │
+86 │   unsafe { return __div(x, y) }
+   │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+   ┌─ src/evm.fe:86:12
+   │
+86 │   unsafe { return __div(x, y) }
+   │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+   ┌─ src/evm.fe:87:1
+   │
+87 │ }
+   │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+   ┌─ src/evm.fe:90:10
+   │
+90 │   unsafe { return __sdiv(x, y) }
+   │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+   ┌─ src/evm.fe:90:10
+   │
+90 │   unsafe { return __sdiv(x, y) }
+   │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+   ┌─ src/evm.fe:90:12
+   │
+90 │   unsafe { return __sdiv(x, y) }
+   │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+   ┌─ src/evm.fe:91:1
+   │
+91 │ }
+   │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected ident for the function name
+   ┌─ src/evm.fe:93:8
+   │
+93 │ pub fn mod(_ x: u256, _ y: u256) -> u256 {
+   │        ^^^ expected ident for the function name
+
+error[1-0001]: unexpected token
+   ┌─ src/evm.fe:93:8
+   │
+93 │ pub fn mod(_ x: u256, _ y: u256) -> u256 {
+   │        ^^^ unexpected token
+
+error[1-0001]: unexpected token
+   ┌─ src/evm.fe:93:8
+   │
+93 │ pub fn mod(_ x: u256, _ y: u256) -> u256 {
+   │        ^^^ unexpected token
+
+error[1-0001]: expected `(` for the function arguments
+   ┌─ src/evm.fe:93:8
+   │
+93 │ pub fn mod(_ x: u256, _ y: u256) -> u256 {
+   │        ^^^ expected `(` for the function arguments
+
+error[1-0001]: unexpected token
+   ┌─ src/evm.fe:93:8
+   │
+93 │ pub fn mod(_ x: u256, _ y: u256) -> u256 {
+   │        ^^^ unexpected token
+
+error[1-0001]: unexpected token
+   ┌─ src/evm.fe:93:8
+   │
+93 │ pub fn mod(_ x: u256, _ y: u256) -> u256 {
+   │        ^^^ unexpected token
+
+error[1-0001]: unexpected token
+   ┌─ src/evm.fe:93:8
+   │
+93 │ pub fn mod(_ x: u256, _ y: u256) -> u256 {
+   │        ^^^ unexpected token
+
+error[1-0001]: function body is required
+   ┌─ src/evm.fe:93:8
+   │
+93 │ pub fn mod(_ x: u256, _ y: u256) -> u256 {
+   │        ^^^ function body is required
+
+error[1-0001]: expected newline after item definition
+   ┌─ src/evm.fe:93:8
+   │
+93 │ pub fn mod(_ x: u256, _ y: u256) -> u256 {
+   │        ^^^ expected newline after item definition
+
+error[1-0001]: expected identifier for the module name
+   ┌─ src/evm.fe:93:11
+   │
+93 │ pub fn mod(_ x: u256, _ y: u256) -> u256 {
+   │           ^ expected identifier for the module name
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+   ┌─ src/evm.fe:94:10
+   │
+94 │   unsafe { return __mod(x, y) }
+   │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+   ┌─ src/evm.fe:94:10
+   │
+94 │   unsafe { return __mod(x, y) }
+   │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+   ┌─ src/evm.fe:98:10
+   │
+98 │   unsafe { return __smod(x, y) }
+   │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+   ┌─ src/evm.fe:98:10
+   │
+98 │   unsafe { return __smod(x, y) }
+   │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+   ┌─ src/evm.fe:98:12
+   │
+98 │   unsafe { return __smod(x, y) }
+   │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+   ┌─ src/evm.fe:99:1
+   │
+99 │ }
+   │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:102:10
+    │
+102 │   unsafe { return __exp(x, y) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:102:10
+    │
+102 │   unsafe { return __exp(x, y) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:102:12
+    │
+102 │   unsafe { return __exp(x, y) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:103:1
+    │
+103 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:106:10
+    │
+106 │   unsafe { return __addmod(x, y, m) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:106:10
+    │
+106 │   unsafe { return __addmod(x, y, m) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:106:12
+    │
+106 │   unsafe { return __addmod(x, y, m) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:107:1
+    │
+107 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:110:10
+    │
+110 │   unsafe { return __mulmod(x, y, m) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:110:10
+    │
+110 │   unsafe { return __mulmod(x, y, m) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:110:12
+    │
+110 │   unsafe { return __mulmod(x, y, m) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:111:1
+    │
+111 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:114:10
+    │
+114 │   unsafe { return __signextend(i, x) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:114:10
+    │
+114 │   unsafe { return __signextend(i, x) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:114:12
+    │
+114 │   unsafe { return __signextend(i, x) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:115:1
+    │
+115 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:121:10
+    │
+121 │   unsafe { return __lt(x, y) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:121:10
+    │
+121 │   unsafe { return __lt(x, y) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:121:12
+    │
+121 │   unsafe { return __lt(x, y) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:122:1
+    │
+122 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:125:10
+    │
+125 │   unsafe { return __gt(x, y) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:125:10
+    │
+125 │   unsafe { return __gt(x, y) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:125:12
+    │
+125 │   unsafe { return __gt(x, y) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:126:1
+    │
+126 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:129:10
+    │
+129 │   unsafe { return __slt(x, y) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:129:10
+    │
+129 │   unsafe { return __slt(x, y) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:129:12
+    │
+129 │   unsafe { return __slt(x, y) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:130:1
+    │
+130 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:133:10
+    │
+133 │   unsafe { return __sgt(x, y) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:133:10
+    │
+133 │   unsafe { return __sgt(x, y) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:133:12
+    │
+133 │   unsafe { return __sgt(x, y) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:134:1
+    │
+134 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:137:10
+    │
+137 │   unsafe { return __eq(x, y) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:137:10
+    │
+137 │   unsafe { return __eq(x, y) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:137:12
+    │
+137 │   unsafe { return __eq(x, y) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:138:1
+    │
+138 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:141:10
+    │
+141 │   unsafe { return __iszero(x) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:141:10
+    │
+141 │   unsafe { return __iszero(x) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:141:12
+    │
+141 │   unsafe { return __iszero(x) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:142:1
+    │
+142 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:147:10
+    │
+147 │   unsafe { return __and(x, y) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:147:10
+    │
+147 │   unsafe { return __and(x, y) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:147:12
+    │
+147 │   unsafe { return __and(x, y) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:148:1
+    │
+148 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:151:10
+    │
+151 │   unsafe { return __or(x, y) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:151:10
+    │
+151 │   unsafe { return __or(x, y) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:151:12
+    │
+151 │   unsafe { return __or(x, y) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:152:1
+    │
+152 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:155:10
+    │
+155 │   unsafe { return __not(x) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:155:10
+    │
+155 │   unsafe { return __not(x) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:155:12
+    │
+155 │   unsafe { return __not(x) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:156:1
+    │
+156 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:159:10
+    │
+159 │   unsafe { return __xor(x, y) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:159:10
+    │
+159 │   unsafe { return __xor(x, y) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:159:12
+    │
+159 │   unsafe { return __xor(x, y) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:160:1
+    │
+160 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:163:10
+    │
+163 │   unsafe { return __byte(offset, value) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:163:10
+    │
+163 │   unsafe { return __byte(offset, value) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:163:12
+    │
+163 │   unsafe { return __byte(offset, value) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:164:1
+    │
+164 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:167:10
+    │
+167 │   unsafe { return __shl(bits, value) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:167:10
+    │
+167 │   unsafe { return __shl(bits, value) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:167:12
+    │
+167 │   unsafe { return __shl(bits, value) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:168:1
+    │
+168 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:171:10
+    │
+171 │   unsafe { return __shr(bits, value) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:171:10
+    │
+171 │   unsafe { return __shr(bits, value) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:171:12
+    │
+171 │   unsafe { return __shr(bits, value) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:172:1
+    │
+172 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:175:10
+    │
+175 │   unsafe { return __sar(bits, value) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:175:10
+    │
+175 │   unsafe { return __sar(bits, value) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:175:12
+    │
+175 │   unsafe { return __sar(bits, value) }
+    │            ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:176:1
+    │
+176 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:181:10
+    │
+181 │    unsafe{ __return(buf.offset(), buf.len()) }
+    │          ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:181:10
+    │
+181 │    unsafe{ __return(buf.offset(), buf.len()) }
+    │          ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:185:12
+    │
+185 │     unsafe { __revert(buf.offset(), buf.len()) }
+    │            ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:185:12
+    │
+185 │     unsafe { __revert(buf.offset(), buf.len()) }
+    │            ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:244:11
+    │
+244 │    unsafe { __calldatacopy(buf.offset(), f, buf.len()) }
+    │           ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:244:11
+    │
+244 │    unsafe { __calldatacopy(buf.offset(), f, buf.len()) }
+    │           ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:276:11
+    │
+276 │    unsafe { return __keccak256(buf.offset(), buf.len()) }
+    │           ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:276:11
+    │
+276 │    unsafe { return __keccak256(buf.offset(), buf.len()) }
+    │           ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:276:13
+    │
+276 │    unsafe { return __keccak256(buf.offset(), buf.len()) }
+    │             ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:277:1
+    │
+277 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:283:12
+    │
+283 │     unsafe { return address(__create(v, buf.offset(), buf.len())) }
+    │            ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:283:12
+    │
+283 │     unsafe { return address(__create(v, buf.offset(), buf.len())) }
+    │            ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:283:14
+    │
+283 │     unsafe { return address(__create(v, buf.offset(), buf.len())) }
+    │              ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:284:1
+    │
+284 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:287:12
+    │
+287 │     unsafe { return address(__create2(v, buf.offset(), buf.len(), s)) }
+    │            ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:287:12
+    │
+287 │     unsafe { return address(__create2(v, buf.offset(), buf.len(), s)) }
+    │            ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:287:14
+    │
+287 │     unsafe { return address(__create2(v, buf.offset(), buf.len(), s)) }
+    │              ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:288:1
+    │
+288 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:292:9
+    │
+292 │   unsafe{ return __call(gas, u256(addr), value, buf.offset(), buf.input_len(), buf.offset(), buf.output_len()) == 1 }
+    │         ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:292:9
+    │
+292 │   unsafe{ return __call(gas, u256(addr), value, buf.offset(), buf.input_len(), buf.offset(), buf.output_len()) == 1 }
+    │         ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:292:11
+    │
+292 │   unsafe{ return __call(gas, u256(addr), value, buf.offset(), buf.input_len(), buf.offset(), buf.output_len()) == 1 }
+    │           ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:293:1
+    │
+293 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:310:12
+    │
+310 │     unsafe { return __log0(buf.offset(), buf.len()) }
+    │            ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:310:12
+    │
+310 │     unsafe { return __log0(buf.offset(), buf.len()) }
+    │            ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:310:14
+    │
+310 │     unsafe { return __log0(buf.offset(), buf.len()) }
+    │              ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:311:1
+    │
+311 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:314:12
+    │
+314 │     unsafe { return __log1(buf.offset(), buf.len(), t1) }
+    │            ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:314:12
+    │
+314 │     unsafe { return __log1(buf.offset(), buf.len(), t1) }
+    │            ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:314:14
+    │
+314 │     unsafe { return __log1(buf.offset(), buf.len(), t1) }
+    │              ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:315:1
+    │
+315 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:318:12
+    │
+318 │     unsafe { return __log2(buf.offset(), buf.len(), t1, t2) }
+    │            ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:318:12
+    │
+318 │     unsafe { return __log2(buf.offset(), buf.len(), t1, t2) }
+    │            ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:318:14
+    │
+318 │     unsafe { return __log2(buf.offset(), buf.len(), t1, t2) }
+    │              ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:319:1
+    │
+319 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:322:12
+    │
+322 │     unsafe { return __log3(buf.offset(), buf.len(), t1, t2, t3) }
+    │            ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:322:12
+    │
+322 │     unsafe { return __log3(buf.offset(), buf.len(), t1, t2, t3) }
+    │            ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:322:14
+    │
+322 │     unsafe { return __log3(buf.offset(), buf.len(), t1, t2, t3) }
+    │              ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:323:1
+    │
+323 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[1-0001]: expected `fn` after `unsafe` keyword
+    ┌─ src/evm.fe:326:12
+    │
+326 │     unsafe { return __log4(buf.offset(), buf.len(), t1, t2, t3, t4) }
+    │            ^ expected `fn` after `unsafe` keyword
+
+error[1-0001]: expected item: but got Some(LBrace)
+    ┌─ src/evm.fe:326:12
+    │
+326 │     unsafe { return __log4(buf.offset(), buf.len(), t1, t2, t3, t4) }
+    │            ^ expected item: but got Some(LBrace)
+
+error[1-0001]: expected newline after item definition
+    ┌─ src/evm.fe:326:14
+    │
+326 │     unsafe { return __log4(buf.offset(), buf.len(), t1, t2, t3, t4) }
+    │              ^^^^^^ expected newline after item definition
+
+error[1-0001]: expected item: but got Some(RBrace)
+    ┌─ src/evm.fe:327:1
+    │
+327 │ }
+    │ ^ expected item: but got Some(RBrace)
+
+error[2-0002]: `math` is not found
+  ┌─ src/buf.fe:2:12
+  │
+2 │ use ingot::math
+  │            ^^^^ `math` is not found
+
+', crates/driver2/tests/std_lib.rs:13:9
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+
+
+failures:
+    check_std_lib
+
+test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.20s
+
diff --git a/crates/driver2/src/lib.rs b/crates/driver2/src/lib.rs
index 601a18858..e3eabde9d 100644
--- a/crates/driver2/src/lib.rs
+++ b/crates/driver2/src/lib.rs
@@ -12,8 +12,11 @@ use common::{
     InputDb, InputFile, InputIngot,
 };
 use hir::{
-    analysis_pass::AnalysisPassManager, diagnostics::DiagnosticVoucher, hir_def::TopLevelMod,
-    lower::map_file_to_mod, HirDb, LowerHirDb, ParsingPass, SpannedHirDb,
+    analysis_pass::AnalysisPassManager,
+    diagnostics::DiagnosticVoucher,
+    hir_def::{IngotId, ModuleTree, TopLevelMod},
+    lower::{map_file_to_mod, module_tree},
+    HirDb, LowerHirDb, ParsingPass, SpannedHirDb,
 };
 use hir_analysis::{
     name_resolution::{DefConflictAnalysisPass, ImportAnalysisPass, PathAnalysisPass},
@@ -58,6 +61,10 @@ impl DriverDataBase {
         self.run_on_file_with_pass_manager(top_mod, initialize_analysis_pass);
     }
 
+    pub fn run_on_ingot(&mut self, ingot: InputIngot) {
+        self.run_on_ingot_with_pass_manager(ingot, initialize_analysis_pass);
+    }
+
     pub fn run_on_file_with_pass_manager<F>(&mut self, top_mod: TopLevelMod, pm_builder: F)
     where
         F: FnOnce(&DriverDataBase) -> AnalysisPassManager<'_>,
@@ -69,6 +76,18 @@ impl DriverDataBase {
         };
     }
 
+    pub fn run_on_ingot_with_pass_manager<F>(&mut self, ingot: InputIngot, pm_builder: F)
+    where
+        F: FnOnce(&DriverDataBase) -> AnalysisPassManager<'_>,
+    {
+        let tree = module_tree(self, ingot);
+        // self.diags.clear();
+        self.diags = {
+            let mut pass_manager = pm_builder(self);
+            pass_manager.run_on_module_tree(tree)
+        };
+    }
+
     pub fn top_mod_from_file(&mut self, file_path: &path::Path, source: &str) -> TopLevelMod {
         let kind = IngotKind::StandAlone;
 
@@ -142,7 +161,7 @@ impl Default for DriverDataBase {
     }
 }
 
-fn initialize_analysis_pass(db: &DriverDataBase) -> AnalysisPassManager<'_> {
+pub fn initialize_analysis_pass(db: &DriverDataBase) -> AnalysisPassManager<'_> {
     let mut pass_manager = AnalysisPassManager::new();
     pass_manager.add_module_pass(Box::new(ParsingPass::new(db)));
     pass_manager.add_module_pass(Box::new(DefConflictAnalysisPass::new(db)));
diff --git a/crates/driver2/tests/std_lib.rs b/crates/driver2/tests/std_lib.rs
new file mode 100644
index 000000000..7d4a5f676
--- /dev/null
+++ b/crates/driver2/tests/std_lib.rs
@@ -0,0 +1,15 @@
+use common::InputDb;
+use fe_driver2::{initialize_analysis_pass, DriverDataBase};
+use hir::lower::module_tree;
+
+#[test]
+fn check_std_lib() {
+    let mut driver = DriverDataBase::default();
+    let std_ingot = library2::std_lib_input_ingot(&mut driver);
+    driver.run_on_ingot(std_ingot);
+
+    let diags = driver.format_diags();
+    if !diags.is_empty() {
+        panic!("{diags}")
+    }
+}
diff --git a/crates/hir/src/analysis_pass.rs b/crates/hir/src/analysis_pass.rs
index ebfad04d0..eb21a2c09 100644
--- a/crates/hir/src/analysis_pass.rs
+++ b/crates/hir/src/analysis_pass.rs
@@ -1,4 +1,7 @@
-use crate::{diagnostics::DiagnosticVoucher, hir_def::TopLevelMod};
+use crate::{
+    diagnostics::DiagnosticVoucher,
+    hir_def::{ModuleTree, TopLevelMod},
+};
 
 /// All analysis passes that run analysis on the HIR top level module
 /// granularity should implement this trait.
@@ -27,4 +30,14 @@ impl<'db> AnalysisPassManager<'db> {
         }
         diags
     }
+
+    pub fn run_on_module_tree(&mut self, tree: &ModuleTree) -> Vec<Box<dyn DiagnosticVoucher>> {
+        let mut diags = vec![];
+        for module in tree.all_modules() {
+            for pass in self.module_passes.iter_mut() {
+                diags.extend(pass.run_on_module(module));
+            }
+        }
+        diags
+    }
 }
diff --git a/crates/library2/Cargo.toml b/crates/library2/Cargo.toml
new file mode 100644
index 000000000..d2ddd0ed7
--- /dev/null
+++ b/crates/library2/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "fe-library2"
+version = "0.23.0"
+authors = ["The Fe Developers <snakecharmers@ethereum.org>"]
+edition = "2021"
+license = "Apache-2.0"
+repository = "https://github.com/ethereum/fe"
+
+[dependencies]
+include_dir = "0.7.2"
+common = { path = "../common2", package = "fe-common2" }
diff --git a/crates/library2/build.rs b/crates/library2/build.rs
new file mode 100644
index 000000000..0ce78ee5e
--- /dev/null
+++ b/crates/library2/build.rs
@@ -0,0 +1,3 @@
+fn main() {
+    println!("cargo:rerun-if-changed=./std");
+}
diff --git a/crates/library2/src/lib.rs b/crates/library2/src/lib.rs
new file mode 100644
index 000000000..da10cc5ee
--- /dev/null
+++ b/crates/library2/src/lib.rs
@@ -0,0 +1,62 @@
+use std::collections::BTreeSet;
+
+pub use ::include_dir;
+use common::{
+    input::{IngotKind, Version},
+    InputDb, InputFile, InputIngot,
+};
+use include_dir::{include_dir, Dir};
+
+pub const STD: Dir = include_dir!("$CARGO_MANIFEST_DIR/std");
+
+fn std_src_input_files(db: &mut dyn InputDb, ingot: InputIngot) -> BTreeSet<InputFile> {
+    static_dir_files(&STD)
+        .into_iter()
+        .map(|(path, content)| InputFile::new(db, ingot, path.into(), content.into()))
+        .collect()
+}
+
+pub fn std_lib_input_ingot(db: &mut dyn InputDb) -> InputIngot {
+    let ingot = InputIngot::new(
+        db,
+        "std",
+        IngotKind::Std,
+        Version::new(0, 0, 0),
+        BTreeSet::default(),
+    );
+
+    let input_files = std_src_input_files(db, ingot);
+    let root_file = input_files
+        .iter()
+        .find(|file| file.path(db).ends_with("lib.fe"))
+        .unwrap()
+        .to_owned();
+
+    ingot.set_root_file(db, root_file);
+
+    ingot.set_files(db, input_files);
+    ingot
+}
+
+// pub fn std_src_files() -> Vec<(&'static str, &'static str)> {
+//     static_dir_files(STD.get_dir("src").unwrap())
+// }
+
+pub fn static_dir_files(dir: &'static Dir) -> Vec<(&'static str, &'static str)> {
+    fn add_files(dir: &'static Dir, accum: &mut Vec<(&'static str, &'static str)>) {
+        accum.extend(dir.files().map(|file| {
+            (
+                file.path().to_str().unwrap(),
+                file.contents_utf8().expect("non-utf8 static file"),
+            )
+        }));
+
+        for sub_dir in dir.dirs() {
+            add_files(sub_dir, accum)
+        }
+    }
+
+    let mut files = vec![];
+    add_files(dir, &mut files);
+    files
+}
diff --git a/crates/library2/std-old/src/buf.fe b/crates/library2/std-old/src/buf.fe
new file mode 100644
index 000000000..ead8086ad
--- /dev/null
+++ b/crates/library2/std-old/src/buf.fe
@@ -0,0 +1,299 @@
+use ingot::evm
+use ingot::math
+
+unsafe fn avail() -> u256 {
+    let ptr: u256 = evm::mload(offset: 64)
+
+    if ptr == 0x00 {
+        return 96
+    } else {
+        return ptr
+    }
+}
+
+unsafe fn alloc(len: u256) -> u256 {
+    let ptr: u256 = avail()
+    evm::mstore(offset: 64, value: ptr + len)
+    return ptr
+}
+
+struct Cursor {
+    cur: u256
+    len: u256
+
+    pub fn new(len: u256) -> Self {
+        return Cursor(cur: 0, len)
+    }
+
+    /// Increment the value of `cur` by `len` and return the value of `cur` before being incremented.
+    /// Reverts if the cursor is advanced beyond the given length.
+    pub fn advance(mut self, len: u256) -> u256 {
+        let cur: u256 = self.cur
+        assert cur + len < self.len + 1
+        self.cur += len
+        return cur 
+    }
+
+    /// Length of the cursor remaining.
+    pub fn remainder(self) -> u256 {
+        return self.len - self.cur
+    }
+}
+
+/// EVM memory buffer abstraction.
+pub struct MemoryBuffer {
+    offset: u256
+    len: u256
+
+    pub fn new(len: u256) -> Self {
+        unsafe {
+            return MemoryBuffer(offset: alloc(len: len + 30), len)
+        }
+    }
+
+    pub fn from_u8(value: u8) -> Self {
+        let mut buf: MemoryBuffer = MemoryBuffer::new(len: 1)
+        let mut writer: MemoryBufferWriter = buf.writer()
+        writer.write(value)
+        return buf
+    }
+
+    /// Length of the buffer in bytes.
+    pub fn len(self) -> u256 {
+        return self.len
+    }
+
+    /// The start of the buffer in EVM memory.
+    pub fn offset(self) -> u256 {
+        return self.offset
+    }
+
+    /// Returns a new buffer reader.
+    pub fn reader(self) -> MemoryBufferReader {
+        return MemoryBufferReader::new(buf: self)
+    }
+
+    /// Returns a new buffer writer.
+    pub fn writer(mut self) -> MemoryBufferWriter {
+        return MemoryBufferWriter::new(buf: self)
+    }
+}
+
+/// Memory buffer writer abstraction.
+pub struct MemoryBufferWriter {
+    buf: MemoryBuffer
+    cur: Cursor 
+
+    /// Returns a new writer for the given buffer.
+    pub fn new(mut buf: MemoryBuffer) -> Self {
+        return MemoryBufferWriter(
+            buf, 
+            cur: Cursor::new(len: buf.len())
+        )
+    }
+
+    /// The number of bytes remaining to be written.
+    pub fn remainder(self) -> u256 {
+        return self.cur.remainder()
+    }
+
+    pub fn write_offset(mut self, len: u256) -> u256 {
+        return self.buf.offset() + self.cur.advance(len)
+    }
+
+    pub fn write_n(mut self, value: u256, len: u256) {
+        let offset: u256 = self.write_offset(len)
+        let shifted_value: u256 = evm::shl(bits: 256 - len * 8, value)
+        unsafe { evm::mstore(offset, value: shifted_value) }
+    }
+
+    pub fn write_buf(mut self, buf: MemoryBuffer) {
+        let mut reader: MemoryBufferReader = buf.reader()
+
+        while true {
+            let bytes_remaining: u256 = reader.remainder() 
+
+            if bytes_remaining >= 32 {
+                self.write(value: reader.read_u256())
+            } else if bytes_remaining == 0 {
+                break 
+            } else {
+                // self.write(value: reader.read_u8())
+            }
+        }
+    }
+
+    pub fn write<T: MemoryBufferWrite>(mut self, value: T) {
+        value.write_buf(writer: self)
+    }
+}
+
+pub trait MemoryBufferWrite {
+    fn write_buf(self, mut writer: MemoryBufferWriter);
+}
+
+impl MemoryBufferWrite for u256 {
+    fn write_buf(self, mut writer: MemoryBufferWriter) {
+        let offset: u256 = writer.write_offset(len: 32)
+        unsafe { evm::mstore(offset, value: self) }
+    }
+}
+
+impl MemoryBufferWrite for u128 {
+    fn write_buf(self, mut writer: MemoryBufferWriter) {
+        writer.write_n(value: u256(self), len: 16)
+    }
+}
+
+impl MemoryBufferWrite for u64 {
+    fn write_buf(self, mut writer: MemoryBufferWriter) {
+        writer.write_n(value: u256(self), len: 8)
+    }
+}
+
+impl MemoryBufferWrite for u32 {
+    fn write_buf(self, mut writer: MemoryBufferWriter) {
+        writer.write_n(value: u256(self), len: 4)
+    }
+}
+
+impl MemoryBufferWrite for u16 {
+    fn write_buf(self, mut writer: MemoryBufferWriter) {
+        writer.write_n(value: u256(self), len: 2)
+    }
+}
+
+impl MemoryBufferWrite for u8 {
+    fn write_buf(self, mut writer: MemoryBufferWriter) {
+        let offset: u256 = writer.write_offset(len: 1)
+        unsafe { evm::mstore8(offset, value: self) }
+    }
+}
+
+// This is needed to prevent the `mir_lower_std_lib` to crash the compiler
+impl MemoryBufferWrite for () {
+    fn write_buf(self, mut writer: MemoryBufferWriter) {}
+}
+
+/// Memory buffer reader abstraction.
+pub struct MemoryBufferReader {
+    buf: MemoryBuffer
+    cur: Cursor 
+
+    /// Returns a new reader for the given buffer.
+    pub fn new(buf: MemoryBuffer) -> Self {
+        return MemoryBufferReader(buf, cur: Cursor::new(len: buf.len()))
+    }
+
+    /// The number of bytes remaining to be read.
+    pub fn remainder(self) -> u256 {
+        return self.cur.remainder()
+    }
+
+    fn read_offset(mut self, len: u256) -> u256 {
+        return self.buf.offset() + self.cur.advance(len)
+    }
+
+    fn read_n(mut self, len: u256) -> u256 {
+        let offset: u256 = self.read_offset(len)
+        unsafe {
+            let value: u256 = evm::mload(offset)
+            return evm::shr(bits: 256 - len * 8, value)
+        }
+    }
+
+    pub fn read_u8(mut self) -> u8 {
+        return u8(self.read_n(len: 1))
+    }
+
+    pub fn read_u16(mut self) -> u16 {
+        return u16(self.read_n(len: 2))
+    }
+
+    pub fn read_u32(mut self) -> u32 {
+        return u32(self.read_n(len: 4))
+    }
+
+    pub fn read_u64(mut self) -> u64 {
+        return u64(self.read_n(len: 8))
+    }
+
+    pub fn read_u128(mut self) -> u128 {
+        return u128(self.read_n(len: 16))
+    }
+
+    pub fn read_u256(mut self) -> u256 {
+        let offset: u256 = self.read_offset(len: 32)
+        unsafe {
+            let value: u256 = evm::mload(offset)
+            return value
+        }
+    }
+
+    pub fn read_buf(mut self, len: u256) -> MemoryBuffer {
+        let mut buf: MemoryBuffer = MemoryBuffer::new(len) 
+        let mut writer: MemoryBufferWriter = buf.writer()
+
+        while true {
+            let bytes_remaining: u256 = writer.remainder()
+
+            if bytes_remaining >= 32 {
+                writer.write(value: self.read_u256())
+            } else if bytes_remaining == 0 {
+                break 
+            } else {
+                writer.write(value: self.read_u8())
+            }
+        }
+
+        return buf
+    }
+
+    // `T` has not been defined
+    // pub fn read<T: MemoryBufferRead>(mut self) -> T {
+    //     T::read_buf(writer: self)
+    // }
+}
+
+// pub trait MemoryBufferRead {
+//     fn read_buf(self, mut reader: MemoryBufferReader) -> Self;
+// }
+// 
+// impl MemoryBufferRead for u256 { .. }
+// .
+// .
+// impl MemoryBufferRead for u8 { .. }
+
+/// `MemoryBuffer` wrapper for raw calls to other contracts.
+pub struct RawCallBuffer {
+    input_len: u256
+    output_len: u256
+    buf: MemoryBuffer
+
+    pub fn new(input_len: u256, output_len: u256) -> Self {
+        let len: u256 = math::max(input_len, output_len) 
+        let buf: MemoryBuffer = MemoryBuffer::new(len)
+
+        return RawCallBuffer(input_len, output_len, buf)
+    }
+
+    pub fn input_len(self) -> u256 {
+        return self.input_len
+    }
+
+    pub fn output_len(self) -> u256 {
+        return self.output_len
+    }
+
+    pub fn offset(self) -> u256 {
+        return self.buf.offset()
+    }
+
+    pub fn reader(self) -> MemoryBufferReader {
+        return self.buf.reader()
+    }
+
+    pub fn writer(mut self) -> MemoryBufferWriter {
+        return self.buf.writer()
+    }
+}
diff --git a/crates/library2/std-old/src/context.fe b/crates/library2/std-old/src/context.fe
new file mode 100644
index 000000000..9b51f9ca9
--- /dev/null
+++ b/crates/library2/std-old/src/context.fe
@@ -0,0 +1,174 @@
+use ingot::evm
+use ingot::error::{
+    ERROR_INSUFFICIENT_FUNDS_TO_SEND_VALUE,
+    ERROR_FAILED_SEND_VALUE,
+    Error
+}
+use ingot::buf::{
+    RawCallBuffer,
+    MemoryBufferReader,
+    MemoryBufferWriter
+}
+
+struct OutOfReachMarker {}
+
+// ctx.emit(my_event) should be the only way to emit an event. We achieve this by defining the
+// private `OutOfReachMarker` here to which only the `Context` has access.
+// Now there is no way to call `emit` directly on an Emittable.
+pub trait Emittable {
+  fn emit(self, _ val: OutOfReachMarker);
+}
+
+pub struct CalldataReader {
+    cur_offset: u256
+    len: u256
+
+    pub unsafe fn new(len: u256) -> CalldataReader {
+        return CalldataReader(cur_offset: 0, len)
+    }
+
+    pub fn remainder(self) -> u256 {
+        return self.len - self.cur_offset
+    }
+
+    pub fn advance(mut self, len: u256) -> u256 {
+        self.cur_offset += len
+        assert self.cur_offset <= self.len
+        return self.cur_offset
+    }
+
+    fn read_n(mut self, len: u256) -> u256 {
+        unsafe {
+            let value: u256 = evm::call_data_load(offset: self.cur_offset)
+            self.advance(len)
+            return evm::shr(bits: 256 - len * 8, value)
+        }
+    }
+
+    pub fn read_u8(mut self) -> u8 {
+        return u8(self.read_n(len: 1))
+    }
+
+    pub fn read_u16(mut self) -> u16 {
+        return u16(self.read_n(len: 2))
+    }
+
+    pub fn read_u32(mut self) -> u32 {
+        return u32(self.read_n(len: 4))
+    }
+
+    pub fn read_u64(mut self) -> u64 {
+        return u64(self.read_n(len: 8))
+    }
+
+    pub fn read_u128(mut self) -> u128 {
+        return u128(self.read_n(len: 16))
+    }
+    pub fn read_u256(mut self) -> u256 {
+        unsafe {
+            let value: u256 = evm::call_data_load(offset: self.cur_offset)
+            self.advance(len: 32)
+            return value
+        }
+    }
+}
+
+pub struct Context {
+    pub fn base_fee(self) -> u256 {
+        unsafe { return evm::base_fee() }
+    }
+
+    pub fn block_coinbase(self) -> address {
+        unsafe { return evm::coinbase() }
+    }
+
+    pub fn prevrandao(self) -> u256 {
+        unsafe { return evm::prevrandao() }
+    }
+
+    pub fn block_number(self) -> u256 {
+        unsafe { return evm::block_number() }
+    }
+
+    pub fn block_timestamp(self) -> u256 {
+        unsafe { return evm::timestamp() }
+    }
+
+    pub fn chain_id(self) -> u256 {
+        unsafe { return evm::chain_id() }
+    }
+
+    pub fn msg_sender(self) -> address {
+        unsafe { return evm::caller() }
+    }
+
+    pub fn msg_value(self) -> u256 {
+        unsafe { return evm::call_value() }
+    }
+
+    pub fn tx_gas_price(self) -> u256 {
+        unsafe { return evm::gas_price() }
+    }
+
+    pub fn tx_origin(self) -> address {
+        unsafe { return evm::origin() }
+    }
+
+    pub fn msg_sig(self) -> u256 {
+        unsafe { return evm::shr(bits: 224, value: evm::call_data_load(offset: 0)) }
+    }
+
+    pub fn balance_of(self, _ account: address) -> u256 {
+        unsafe { return evm::balance_of(account) }
+    }
+
+    pub fn self_balance(self) -> u256 {
+        unsafe { return evm::balance() }
+    }
+
+    pub fn self_address(self) -> address {
+        unsafe { return address(__address()) }
+    }
+
+    pub fn calldata_reader(self) -> CalldataReader {
+        unsafe {
+            let len: u256 = evm::call_data_size()
+            return CalldataReader::new(len)
+        }
+    }
+
+    pub fn send_value(mut self, to: address, wei: u256) {
+        unsafe {
+            if evm::balance() < wei {
+                revert Error(code: ERROR_INSUFFICIENT_FUNDS_TO_SEND_VALUE)
+            }
+            let mut buf: RawCallBuffer = RawCallBuffer::new(input_len: 0, output_len: 0)
+            let success: bool = evm::call(gas: evm::gas_remaining(), addr: to, value: wei,
+                                          buf)
+            if not success {
+                revert Error(code: ERROR_FAILED_SEND_VALUE)
+            }
+        }
+    }
+
+    /// Makes a call to the given address.
+    pub fn raw_call(
+        self,
+        addr: address,
+        value: u256,
+        mut buf: RawCallBuffer
+    ) -> bool {
+        unsafe {
+            return evm::call(
+                gas: evm::gas_remaining(),
+                addr,
+                value,
+                buf
+            )
+        }
+    }
+
+    pub fn emit<T: Emittable>(mut self, _ val: T) {
+        val.emit(OutOfReachMarker())
+    }
+}
\ No newline at end of file
diff --git a/crates/library2/std-old/src/error.fe b/crates/library2/std-old/src/error.fe
new file mode 100644
index 000000000..7ae066af4
--- /dev/null
+++ b/crates/library2/std-old/src/error.fe
@@ -0,0 +1,6 @@
+pub const ERROR_INSUFFICIENT_FUNDS_TO_SEND_VALUE: u256 = 0x100
+pub const ERROR_FAILED_SEND_VALUE: u256 = 0x101
+
+pub struct Error {
+    pub code: u256
+}
\ No newline at end of file
diff --git a/crates/library2/std-old/src/math.fe b/crates/library2/std-old/src/math.fe
new file mode 100644
index 000000000..bc37ee673
--- /dev/null
+++ b/crates/library2/std-old/src/math.fe
@@ -0,0 +1,15 @@
+pub fn min(_ x: u256, _ y: u256) -> u256 {
+    if x < y {
+        return x
+    } else {
+        return y
+    }
+}
+
+pub fn max(_ x: u256, _ y: u256) -> u256 {
+    if x > y {
+        return x
+    } else {
+        return y
+    }
+}
\ No newline at end of file
diff --git a/crates/library2/std-old/src/precompiles.fe b/crates/library2/std-old/src/precompiles.fe
new file mode 100644
index 000000000..ba9d59f13
--- /dev/null
+++ b/crates/library2/std-old/src/precompiles.fe
@@ -0,0 +1,191 @@
+use ingot::buf::{MemoryBuffer, MemoryBufferWriter, MemoryBufferReader}
+use ingot::evm
+
+enum Precompile {
+    EcRecover
+    Sha2256
+    Ripemd160
+    Identity
+    ModExp
+    EcAdd
+    EcMul
+    EcPairing
+    Blake2f
+
+    pub fn addr(self) -> address {
+        match self {
+            Precompile::EcRecover => { return 0x01 }
+            Precompile::Sha2256 => { return 0x02 }
+            Precompile::Ripemd160 => { return 0x03 }
+            Precompile::Identity => { return 0x04 }
+            Precompile::ModExp => { return 0x05 }
+            Precompile::EcAdd => { return 0x06 }
+            Precompile::EcMul => { return 0x07 }
+            Precompile::EcPairing => { return 0x08 }
+            Precompile::Blake2f => { return 0x09 }
+        }
+    }
+
+    pub fn single_buf_call(self, mut buf: MemoryBuffer) {
+        unsafe {
+            assert evm::static_call(
+                gas: evm::gas_remaining(), 
+                addr: self.addr(), 
+                input_offset: buf.offset(), 
+                input_len: buf.len(), 
+                output_offset: buf.offset(), 
+                output_len: buf.len()
+            ) == 1
+        }
+    }
+
+    pub fn call(self, input: MemoryBuffer, mut output: MemoryBuffer) {
+        unsafe {
+            assert evm::static_call(
+                gas: evm::gas_remaining(), 
+                addr: self.addr(), 
+                input_offset: input.offset(), 
+                input_len: input.len(), 
+                output_offset: output.offset(), 
+                output_len: output.len()
+            ) == 1
+        }
+    }
+}
+
+/// EC Recover precompile call.
+pub fn ec_recover(hash: u256, v: u256, r: u256, s: u256) -> address {
+    let mut buf: MemoryBuffer = MemoryBuffer::new(len: 128) 
+
+    let mut writer: MemoryBufferWriter = buf.writer()
+    writer.write(value: hash)
+    writer.write(value: v)
+    writer.write(value: r)
+    writer.write(value: s)
+
+    Precompile::EcRecover.single_buf_call(buf)
+
+    let mut reader: MemoryBufferReader = buf.reader()
+    return address(reader.read_u256())
+}
+
+/// SHA2 256 precompile call.
+pub fn sha2_256(buf: MemoryBuffer) -> u256 {
+    let mut output: MemoryBuffer = MemoryBuffer::new(len: 32) 
+    let mut reader: MemoryBufferReader = output.reader()
+    Precompile::Sha2256.call(input: buf, output)
+    return reader.read_u256()
+}
+
+/// Ripemd 160 precompile call.
+pub fn ripemd_160(buf: MemoryBuffer) -> u256 {
+    let mut output: MemoryBuffer = MemoryBuffer::new(len: 32) 
+    let mut reader: MemoryBufferReader = output.reader()
+    Precompile::Ripemd160.call(input: buf, output)
+    return reader.read_u256()
+}
+
+/// Identity precompile call.
+pub fn identity(buf: MemoryBuffer) -> MemoryBuffer {
+    let mut output: MemoryBuffer = MemoryBuffer::new(len: buf.len()) 
+    Precompile::Identity.call(input: buf, output)
+    return output
+}
+
+/// Mod exp preocmpile call.
+pub fn mod_exp(
+    b_size: u256, 
+    e_size: u256, 
+    m_size: u256,
+    b: MemoryBuffer,
+    e: MemoryBuffer,
+    m: MemoryBuffer,
+) -> MemoryBuffer {
+    let mut buf: MemoryBuffer = MemoryBuffer::new(
+        len: 96 + b_size + e_size + m_size
+    ) 
+
+    let mut writer: MemoryBufferWriter = buf.writer()
+    writer.write(value: b_size)
+    writer.write(value: e_size)
+    writer.write(value: m_size)
+    writer.write_buf(buf: b)
+    writer.write_buf(buf: e)
+    writer.write_buf(buf: m)
+
+    Precompile::ModExp.single_buf_call(buf)
+
+    let mut reader: MemoryBufferReader = buf.reader()
+    return reader.read_buf(len: m_size)
+}
+
+/// EC add precompile call.
+pub fn ec_add(x1: u256, y1: u256, x2: u256, y2: u256) -> (u256, u256) {
+    let mut buf: MemoryBuffer = MemoryBuffer::new(len: 128) 
+    let mut writer: MemoryBufferWriter = buf.writer()
+
+    writer.write(value: x1)
+    writer.write(value: y1)
+    writer.write(value: x2)
+    writer.write(value: y2)
+
+    Precompile::EcAdd.single_buf_call(buf)
+
+    let mut reader: MemoryBufferReader = buf.reader()
+    return (reader.read_u256(), reader.read_u256())
+}
+
+/// EC mul precompile call.
+pub fn ec_mul(x: u256, y: u256, s: u256) -> (u256, u256) {
+    let mut buf: MemoryBuffer = MemoryBuffer::new(len: 128) 
+    let mut writer: MemoryBufferWriter = buf.writer()
+
+    writer.write(value: x)
+    writer.write(value: y)
+    writer.write(value: s)
+
+    Precompile::EcMul.single_buf_call(buf)
+
+    let mut reader: MemoryBufferReader = buf.reader()
+    return (reader.read_u256(), reader.read_u256())
+}
+
+/// EC pairing precompile call.
+pub fn ec_pairing(buf: MemoryBuffer) -> bool {
+    let mut output: MemoryBuffer = MemoryBuffer::new(len: 32) 
+    let mut reader: MemoryBufferReader = output.reader()
+    Precompile::EcPairing.call(input: buf, output)
+    return reader.read_u256() == 1
+}
+
+/// Blake 2f precompile call.
+pub fn blake_2f(
+    rounds: u32, 
+    h: Array<u64, 8>, 
+    m: Array<u64, 16>,
+    t: Array<u64, 2>,
+    f: bool
+) ->  Array<u64, 8> {
+    let mut buf: MemoryBuffer = MemoryBuffer::new(len: 213) 
+    let mut writer: MemoryBufferWriter = buf.writer()
+
+    writer.write(value: rounds)
+    for value in h { writer.write(value) }
+    for value in m { writer.write(value) }
+    for value in t { writer.write(value) }
+    writer.write(value: u8(1) if f else u8(0))
+
+    Precompile::Blake2f.single_buf_call(buf)
+
+    let mut reader: MemoryBufferReader = buf.reader()
+    return [
+        reader.read_u64(),
+        reader.read_u64(),
+        reader.read_u64(),
+        reader.read_u64(),
+        reader.read_u64(),
+        reader.read_u64(),
+        reader.read_u64(),
+        reader.read_u64()
+    ]
+}
diff --git a/crates/library2/std-old/src/prelude.fe b/crates/library2/std-old/src/prelude.fe
new file mode 100644
index 000000000..715ec70cf
--- /dev/null
+++ b/crates/library2/std-old/src/prelude.fe
@@ -0,0 +1 @@
+use ingot::context::Context
\ No newline at end of file
diff --git a/crates/library2/std-old/src/traits.fe b/crates/library2/std-old/src/traits.fe
new file mode 100644
index 000000000..43a0f4472
--- /dev/null
+++ b/crates/library2/std-old/src/traits.fe
@@ -0,0 +1,160 @@
+// Dummy trait used in testing. We can remove this once we have more useful traits
+
+pub trait Dummy {}
+
+pub trait Min {
+  fn min() -> Self;
+}
+
+impl Min for u8 {
+  fn min() -> Self {
+    return 0
+  }
+}
+
+impl Min for u16 {
+  fn min() -> Self {
+    return 0
+  }
+}
+
+impl Min for u32 {
+  fn min() -> Self {
+    return 0
+  }
+}
+
+impl Min for u64 {
+  fn min() -> Self {
+    return 0
+  }
+}
+
+impl Min for u128 {
+  fn min() -> Self {
+    return 0
+  }
+}
+
+impl Min for u256 {
+  fn min() -> Self {
+    return 0
+  }
+}
+
+impl Min for i8 {
+  fn min() -> Self {
+    return -128
+  }
+}
+
+impl Min for i16 {
+  fn min() -> Self {
+    return -32768
+  }
+}
+
+impl Min for i32 {
+  fn min() -> Self {
+    return -2147483648
+  }
+}
+
+impl Min for i64 {
+  fn min() -> Self {
+    return -9223372036854775808
+  }
+}
+
+impl Min for i128 {
+  fn min() -> Self {
+    return -170141183460469231731687303715884105728
+  }
+}
+
+impl Min for i256 {
+  fn min() -> Self {
+    return -57896044618658097711785492504343953926634992332820282019728792003956564819968
+  }
+}
+
+
+
+
+
+
+pub trait Max {
+  fn max() -> Self;
+}
+
+impl Max for u8 {
+  fn max() -> Self {
+    return 255
+  }
+}
+
+impl Max for u16 {
+  fn max() -> Self {
+    return 65535
+  }
+}
+
+impl Max for u32 {
+  fn max() -> Self {
+    return 4294967295
+  }
+}
+
+impl Max for u64 {
+  fn max() -> Self {
+    return 18446744073709551615
+  }
+}
+
+impl Max for u128 {
+  fn max() -> Self {
+    return 340282366920938463463374607431768211455
+  }
+}
+
+impl Max for u256 {
+  fn max() -> Self {
+    return 115792089237316195423570985008687907853269984665640564039457584007913129639935
+  }
+}
+
+impl Max for i8 {
+  fn max() -> Self {
+    return 127
+  }
+}
+
+impl Max for i16 {
+  fn max() -> Self {
+    return 32767
+  }
+}
+
+impl Max for i32 {
+  fn max() -> Self {
+    return 2147483647
+  }
+}
+
+impl Max for i64 {
+  fn max() -> Self {
+    return 9223372036854775807
+  }
+}
+
+impl Max for i128 {
+  fn max() -> Self {
+    return 170141183460469231731687303715884105727
+  }
+}
+
+impl Max for i256 {
+  fn max() -> Self {
+    return 57896044618658097711785492504343953926634992332820282019728792003956564819967
+  }
+}
diff --git a/crates/library2/std/src/buf.fe b/crates/library2/std/src/buf.fe
new file mode 100644
index 000000000..646172bae
--- /dev/null
+++ b/crates/library2/std/src/buf.fe
@@ -0,0 +1,309 @@
+use ingot::evm
+use ingot::math
+
+unsafe fn avail() -> u256 {
+    let ptr: u256 = evm::mload(offset: 64)
+
+    if ptr == 0x00 {
+        return 96
+    } else {
+        return ptr
+    }
+}
+
+unsafe fn alloc(len: u256) -> u256 {
+    let ptr: u256 = avail()
+    evm::mstore(offset: 64, value: ptr + len)
+    return ptr
+}
+
+struct Cursor {
+    cur: u256,
+    len: u256
+}
+
+impl Cursor {
+    pub fn new(len: u256) -> Self {
+        return Cursor(cur: 0, len)
+    }
+
+    /// Increment the value of `cur` by `len` and return the value of `cur` before being incremented.
+    /// Reverts if the cursor is advanced beyond the given length.
+    pub fn advance(mut self, len: u256) -> u256 {
+        let cur: u256 = self.cur
+        // assert cur + len < self.len + 1
+        self.cur += len
+        return cur 
+    }
+
+    /// Length of the cursor remaining.
+    pub fn remainder(self) -> u256 {
+        return self.len - self.cur
+    }
+}
+
+/// EVM memory buffer abstraction.
+pub struct MemoryBuffer {
+    offset: u256,
+    len: u256
+}
+
+impl MemoryBuffer {
+    pub fn new(len: u256) -> Self {
+        unsafe {
+            return MemoryBuffer(offset: alloc(len: len + 30), len)
+        }
+    }
+
+    pub fn from_u8(value: u8) -> Self {
+        let mut buf: MemoryBuffer = MemoryBuffer::new(len: 1)
+        let mut writer: MemoryBufferWriter = buf.writer()
+        writer.write(value)
+        return buf
+    }
+
+    /// Length of the buffer in bytes.
+    pub fn len(self) -> u256 {
+        return self.len
+    }
+
+    /// The start of the buffer in EVM memory.
+    pub fn offset(self) -> u256 {
+        return self.offset
+    }
+
+    /// Returns a new buffer reader.
+    pub fn reader(self) -> MemoryBufferReader {
+        return MemoryBufferReader::new(buf: self)
+    }
+
+    /// Returns a new buffer writer.
+    pub fn writer(mut self) -> MemoryBufferWriter {
+        return MemoryBufferWriter::new(buf: self)
+    }
+}
+
+/// Memory buffer writer abstraction.
+pub struct MemoryBufferWriter {
+    buf: MemoryBuffer,
+    cur: Cursor 
+}
+
+impl MemoryBufferWriter {
+    /// Returns a new writer for the given buffer.
+    pub fn new(mut buf: MemoryBuffer) -> Self {
+        return MemoryBufferWriter(
+            buf, 
+            cur: Cursor::new(len: buf.len())
+        )
+    }
+
+    /// The number of bytes remaining to be written.
+    pub fn remainder(self) -> u256 {
+        return self.cur.remainder()
+    }
+
+    pub fn write_offset(mut self, len: u256) -> u256 {
+        return self.buf.offset() + self.cur.advance(len)
+    }
+
+    pub fn write_n(mut self, value: u256, len: u256) {
+        let offset: u256 = self.write_offset(len)
+        let shifted_value: u256 = evm::shl(bits: 256 - len * 8, value)
+        unsafe { evm::mstore(offset, value: shifted_value) }
+    }
+
+    pub fn write_buf(mut self, buf: MemoryBuffer) {
+        let mut reader: MemoryBufferReader = buf.reader()
+
+        while true {
+            let bytes_remaining: u256 = reader.remainder() 
+
+            if bytes_remaining >= 32 {
+                self.write(value: reader.read_u256())
+            } else if bytes_remaining == 0 {
+                break 
+            } else {
+                self.write(value: reader.read_u8())
+            }
+        }
+    }
+
+    pub fn write<T: MemoryBufferWrite>(mut self, value: T) {
+        value.write_buf(writer: self)
+    }
+}
+
+pub trait MemoryBufferWrite {
+    fn write_buf(self, mut writer: MemoryBufferWriter)
+}
+
+impl MemoryBufferWrite for u256 {
+    fn write_buf(self, mut writer: MemoryBufferWriter) {
+        let offset: u256 = writer.write_offset(len: 32)
+        unsafe { evm::mstore(offset, value: self) }
+    }
+}
+
+impl MemoryBufferWrite for u128 {
+    fn write_buf(self, mut writer: MemoryBufferWriter) {
+        writer.write_n(value: u256(self), len: 16)
+    }
+}
+
+impl MemoryBufferWrite for u64 {
+    fn write_buf(self, mut writer: MemoryBufferWriter) {
+        writer.write_n(value: u256(self), len: 8)
+    }
+}
+
+impl MemoryBufferWrite for u32 {
+    fn write_buf(self, mut writer: MemoryBufferWriter) {
+        writer.write_n(value: u256(self), len: 4)
+    }
+}
+
+impl MemoryBufferWrite for u16 {
+    fn write_buf(self, mut writer: MemoryBufferWriter) {
+        writer.write_n(value: u256(self), len: 2)
+    }
+}
+
+impl MemoryBufferWrite for u8 {
+    fn write_buf(self, mut writer: MemoryBufferWriter) {
+        let offset: u256 = writer.write_offset(len: 1)
+        unsafe { evm::mstore8(offset, value: self) }
+    }
+}
+
+// This is needed to prevent the `mir_lower_std_lib` to crash the compiler
+impl MemoryBufferWrite for () {
+    fn write_buf(self, mut writer: MemoryBufferWriter) {}
+}
+
+/// Memory buffer reader abstraction.
+pub struct MemoryBufferReader {
+    buf: MemoryBuffer,
+    cur: Cursor 
+}
+
+impl MemoryBufferReader {
+    /// Returns a new reader for the given buffer.
+    pub fn new(buf: MemoryBuffer) -> Self {
+        return MemoryBufferReader(buf, cur: Cursor::new(len: buf.len()))
+    }
+
+    /// The number of bytes remaining to be read.
+    pub fn remainder(self) -> u256 {
+        return self.cur.remainder()
+    }
+
+    fn read_offset(mut self, len: u256) -> u256 {
+        return self.buf.offset() + self.cur.advance(len)
+    }
+
+    fn read_n(mut self, len: u256) -> u256 {
+        let offset: u256 = self.read_offset(len)
+        unsafe {
+            let value: u256 = evm::mload(offset)
+            return evm::shr(bits: 256 - len * 8, value)
+        }
+    }
+
+    pub fn read_u8(mut self) -> u8 {
+        return u8(self.read_n(len: 1))
+    }
+
+    pub fn read_u16(mut self) -> u16 {
+        return u16(self.read_n(len: 2))
+    }
+
+    pub fn read_u32(mut self) -> u32 {
+        return u32(self.read_n(len: 4))
+    }
+
+    pub fn read_u64(mut self) -> u64 {
+        return u64(self.read_n(len: 8))
+    }
+
+    pub fn read_u128(mut self) -> u128 {
+        return u128(self.read_n(len: 16))
+    }
+
+    pub fn read_u256(mut self) -> u256 {
+        let offset: u256 = self.read_offset(len: 32)
+        unsafe {
+            let value: u256 = evm::mload(offset)
+            return value
+        }
+    }
+
+    pub fn read_buf(mut self, len: u256) -> MemoryBuffer {
+        let mut buf: MemoryBuffer = MemoryBuffer::new(len) 
+        let mut writer: MemoryBufferWriter = buf.writer()
+
+        while true {
+            let bytes_remaining: u256 = writer.remainder()
+
+            if bytes_remaining >= 32 {
+                writer.write(value: self.read_u256())
+            } else if bytes_remaining == 0 {
+                break 
+            } else {
+                writer.write(value: self.read_u8())
+            }
+        }
+
+        return buf
+    }
+
+    // `T` has not been defined
+    // pub fn read<T: MemoryBufferRead>(mut self) -> T {
+    //     T::read_buf(writer: self)
+    // }
+}
+
+// pub trait MemoryBufferRead {
+//     fn read_buf(self, mut reader: MemoryBufferReader) -> Self;
+// }
+// 
+// impl MemoryBufferRead for u256 { .. }
+// .
+// .
+// impl MemoryBufferRead for u8 { .. }
+
+/// `MemoryBuffer` wrapper for raw calls to other contracts.
+pub struct RawCallBuffer {
+    input_len: u256,
+    output_len: u256,
+    buf: MemoryBuffer
+}
+
+impl RawCallBuffer {
+    pub fn new(input_len: u256, output_len: u256) -> Self {
+        let len: u256 = math::max(input_len, output_len) 
+        let buf: MemoryBuffer = MemoryBuffer::new(len)
+
+        return RawCallBuffer(input_len, output_len, buf)
+    }
+
+    pub fn input_len(self) -> u256 {
+        return self.input_len
+    }
+
+    pub fn output_len(self) -> u256 {
+        return self.output_len
+    }
+
+    pub fn offset(self) -> u256 {
+        return self.buf.offset()
+    }
+
+    pub fn reader(self) -> MemoryBufferReader {
+        return self.buf.reader()
+    }
+
+    pub fn writer(mut self) -> MemoryBufferWriter {
+        return self.buf.writer()
+    }
+}
diff --git a/crates/library2/std/src/evm.fe b/crates/library2/std/src/evm.fe
new file mode 100644
index 000000000..3d352a45b
--- /dev/null
+++ b/crates/library2/std/src/evm.fe
@@ -0,0 +1,326 @@
+// use ingot::buf::{MemoryBuffer, RawCallBuffer}
+
+type address = u256
+
+// Basic context accessor functions.
+pub unsafe fn chain_id() -> u256 {
+  return __chainid()
+}
+
+pub unsafe fn base_fee() -> u256 {
+  return __basefee()
+}
+
+pub unsafe fn origin() -> address {
+  return address(__origin())
+}
+
+pub unsafe fn gas_price() -> u256 {
+  return __gasprice()
+}
+
+pub unsafe fn gas_limit() -> u256 {
+  return __gaslimit()
+}
+
+pub unsafe fn gas_remaining() -> u256 {
+  return __gas()
+}
+
+pub unsafe fn block_hash(_ b: u256) -> u256 {
+  return __blockhash(b)
+}
+
+pub unsafe fn coinbase() -> address {
+  return address(__coinbase())
+}
+
+pub unsafe fn timestamp() -> u256 {
+  return __timestamp()
+}
+
+pub unsafe fn block_number() -> u256 {
+  return __number()
+}
+
+pub unsafe fn prevrandao() -> u256 {
+  return __prevrandao()
+}
+
+pub unsafe fn self_address() -> address {
+  return address(__address())
+}
+
+pub unsafe fn balance_of(_ addr: address) -> u256 {
+  return __balance(u256(addr))
+}
+
+pub unsafe fn balance() -> u256 {
+  return __selfbalance()
+}
+
+pub unsafe fn caller() -> address {
+  return address(__caller())
+}
+
+pub unsafe fn call_value() -> u256 {
+  return __callvalue()
+}
+
+
+// Overflowing math ops. Should these be unsafe or named
+// `overflowing_add`, etc?
+pub fn add(_ x: u256, _ y: u256) -> u256 {
+  unsafe { return __add(x, y) }
+}
+
+pub fn sub(_ x: u256, _ y: u256) -> u256 {
+  unsafe { return __sub(x, y) }
+}
+
+pub fn mul(_ x: u256, _ y: u256) -> u256 {
+  unsafe { return __mul(x, y) }
+}
+
+pub fn div(_ x: u256, _ y: u256) -> u256 {
+  unsafe { return __div(x, y) }
+}
+
+pub fn sdiv(_ x: u256, _ y: u256) -> u256 {
+  unsafe { return __sdiv(x, y) }
+}
+
+pub fn _mod(_ x: u256, _ y: u256) -> u256 {
+  unsafe { return __mod(x, y) }
+}
+
+pub fn smod(_ x: u256, _ y: u256) -> u256 {
+  unsafe { return __smod(x, y) }
+}
+
+pub fn exp(_ x: u256, _ y: u256) -> u256 {
+  unsafe { return __exp(x, y) }
+}
+
+pub fn addmod(_ x: u256, _ y: u256, _ m: u256) -> u256 {
+  unsafe { return __addmod(x, y, m) }
+}
+
+pub fn mulmod(_ x: u256, _ y: u256, _ m: u256) -> u256 {
+  unsafe { return __mulmod(x, y, m) }
+}
+
+pub fn sign_extend(_ i: u256, _ x: u256) -> u256 {
+  unsafe { return __signextend(i, x) }
+}
+
+
+// Comparison ops
+// TODO: return bool (see issue //653)
+pub fn lt(_ x: u256, _ y: u256) -> u256 {
+  unsafe { return __lt(x, y) }
+}
+
+pub fn gt(_ x: u256, _ y: u256) -> u256 {
+  unsafe { return __gt(x, y) }
+}
+
+pub fn slt(_ x: u256, _ y: u256) -> u256 {
+  unsafe { return __slt(x, y) }
+}
+
+pub fn sgt(_ x: u256, _ y: u256) -> u256 {
+  unsafe { return __sgt(x, y) }
+}
+
+pub fn eq(_ x: u256, _ y: u256) -> u256 {
+  unsafe { return __eq(x, y) }
+}
+
+pub fn is_zero(_ x: u256) -> u256 {
+  unsafe { return __iszero(x) }
+}
+
+
+// Bitwise ops
+pub fn bitwise_and(_ x: u256, _ y: u256) -> u256 {
+  unsafe { return __and(x, y) }
+}
+
+pub fn bitwise_or(_ x: u256, _ y: u256) -> u256 {
+  unsafe { return __or(x, y) }
+}
+
+pub fn bitwise_not(_ x: u256) -> u256 {
+  unsafe { return __not(x) }
+}
+
+pub fn xor(_ x: u256, _ y: u256) -> u256 {
+  unsafe { return __xor(x, y) }
+}
+
+pub fn byte(offset: u256, value: u256) -> u256 {
+  unsafe { return __byte(offset, value) }
+}
+
+pub fn shl(bits: u256, value: u256) -> u256 {
+  unsafe { return __shl(bits, value) }
+}
+
+pub fn shr(bits: u256, value: u256) -> u256 {
+  unsafe { return __shr(bits, value) }
+}
+
+pub fn sar(bits: u256, value: u256) -> u256 {
+  unsafe { return __sar(bits, value) }
+}
+
+
+// // Evm state access and control
+// pub fn return_mem(buf: MemoryBuffer) {
+//    unsafe{ __return(buf.offset(), buf.len()) }
+// }
+
+// pub fn revert_mem(buf: MemoryBuffer) {
+//     unsafe { __revert(buf.offset(), buf.len()) }
+// }
+
+pub unsafe fn selfdestruct(_ addr: address) {
+    __selfdestruct(u256(addr))
+}
+
+// Invalid opcode. Equivalent to revert(0, 0),
+// except that all remaining gas in the current context
+// is consumed.
+pub unsafe fn invalid() {
+    __invalid()
+}
+
+pub unsafe fn stop() {
+    __stop()
+}
+
+pub unsafe fn pc() -> u256 {
+    return __pc()
+}
+
+// TODO: dunno if we should enable this
+// pub unsafe fn pop(_ x: u256) {
+//     return __pop(x)
+// }
+
+pub unsafe fn mload(offset p: u256) -> u256 {
+    return __mload(p)
+}
+
+pub unsafe fn mstore(offset p: u256, value v: u256) {
+    __mstore(p, v)
+}
+pub unsafe fn mstore8(offset p: u256, value v: u256) {
+    __mstore8(p, v)
+}
+
+pub unsafe fn sload(offset p: u256) -> u256 {
+    return __sload(p)
+}
+
+pub unsafe fn sstore(offset p: u256, value v: u256) {
+    __sstore(p, v)
+}
+
+pub unsafe fn msize() -> u256 {
+    return __msize()
+}
+
+pub unsafe fn call_data_load(offset p: u256) -> u256 {
+    return __calldataload(p)
+}
+
+pub unsafe fn call_data_size() -> u256 {
+    return __calldatasize()
+}
+
+// pub fn call_data_copy(buf: MemoryBuffer, from_offset f: u256) {
+//    unsafe { __calldatacopy(buf.offset(), f, buf.len()) }
+// }
+
+pub unsafe fn code_size() -> u256 {
+    return __codesize()
+}
+
+pub unsafe fn code_copy(to_offset t: u256, from_offset f: u256, len: u256) {
+    __codecopy(t, f, len)
+}
+
+pub unsafe fn return_data_size() -> u256 {
+    return __returndatasize()
+}
+
+pub unsafe fn return_data_copy(to_offset t: u256, from_offset f: u256, len: u256) {
+    __returndatacopy(t, f, len)
+}
+
+pub unsafe fn extcodesize(_ addr: address) -> u256 {
+    return __extcodesize(u256(addr))
+}
+
+pub unsafe fn ext_code_copy(_ addr: address, to_offset t: u256, from_offset f: u256, len: u256) {
+    __extcodecopy(u256(addr), t, f, len)
+}
+
+pub unsafe fn ext_code_hash(_ addr: address) -> u256 {
+    return __extcodehash(u256(addr))
+}
+
+// pub fn keccak256_mem(buf: MemoryBuffer) -> u256 {
+//    unsafe { return __keccak256(buf.offset(), buf.len()) }
+// }
+
+
+// Contract creation and calling
+
+// pub fn create(value v: u256, buf: MemoryBuffer) -> address {
+//     unsafe { return address(__create(v, buf.offset(), buf.len())) }
+// }
+
+// pub fn create2(value v: u256, buf: MemoryBuffer, salt s: u256) -> address {
+//     unsafe { return address(__create2(v, buf.offset(), buf.len(), s)) }
+// }
+
+// pub fn call(gas: u256, addr: address, value: u256, mut buf: RawCallBuffer) -> bool {
+//   unsafe{ return __call(gas, u256(addr), value, buf.offset(), buf.input_len(), buf.offset(), buf.output_len()) == 1 }
+// }
+
+pub unsafe fn call_code(gas: u256, addr: address, value: u256, input_offset: u256, input_len: u256, output_offset: u256, output_len: u256) -> u256 {
+    return __callcode(gas, u256(addr), value, input_offset, input_len, output_offset, output_len)
+}
+
+pub unsafe fn delegate_call(gas: u256, addr: address, value: u256, input_offset: u256, input_len: u256, output_offset: u256, output_len: u256) -> u256 {
+    return __delegatecall(gas, u256(addr), input_offset, input_len, output_offset, output_len)
+}
+
+pub unsafe fn static_call(gas: u256, addr: address, input_offset: u256, input_len: u256, output_offset: u256, output_len: u256) -> u256 {
+    return __staticcall(gas, u256(addr), input_offset, input_len, output_offset, output_len)
+}
+
+// Logging functions
+
+// pub fn log0(buf: MemoryBuffer) {
+//     unsafe { return __log0(buf.offset(), buf.len()) }
+// }
+
+// pub fn log1(buf: MemoryBuffer, topic1 t1: u256) {
+//     unsafe { return __log1(buf.offset(), buf.len(), t1) }
+// }
+
+// pub fn log2(buf: MemoryBuffer, topic1 t1: u256, topic2 t2: u256) {
+//     unsafe { return __log2(buf.offset(), buf.len(), t1, t2) }
+// }
+
+// pub fn log3(buf: MemoryBuffer, topic1 t1: u256, topic2 t2: u256, topic3 t3: u256) {
+//     unsafe { return __log3(buf.offset(), buf.len(), t1, t2, t3) }
+// }
+
+// pub fn log4(buf: MemoryBuffer, topic1 t1: u256, topic2 t2: u256, topic3 t3: u256, topic4 t4: u256) {
+//     unsafe { return __log4(buf.offset(), buf.len(), t1, t2, t3, t4) }
+// }
diff --git a/crates/library2/std/src/lib.fe b/crates/library2/std/src/lib.fe
new file mode 100644
index 000000000..e69de29bb
diff --git a/crates/library2/std/src/math.fe b/crates/library2/std/src/math.fe
new file mode 100644
index 000000000..bc37ee673
--- /dev/null
+++ b/crates/library2/std/src/math.fe
@@ -0,0 +1,15 @@
+pub fn min(_ x: u256, _ y: u256) -> u256 {
+    if x < y {
+        return x
+    } else {
+        return y
+    }
+}
+
+pub fn max(_ x: u256, _ y: u256) -> u256 {
+    if x > y {
+        return x
+    } else {
+        return y
+    }
+}
\ No newline at end of file