binop: expand `not` operator as loglcal not

[ast] Refactor lazy_static to LazyLock
It is available in Rust 1.80 and reduces a dependency.
2024-11-08 17:12:01 +08:00 · 2024-10-30 12:29:51 +08:00 · 2024-10-30 12:29:51 +08:00 · 2024-10-18 14:17:16 +08:00 · 2024-10-18 14:16:42 +08:00 · 2024-10-17 16:25:52 +08:00
103 changed files with 11931 additions and 7959 deletions
--- a/.clang-format
+++ b/.clang-format
@ -0,0 +1,32 @@
+BasedOnStyle: LLVM
+
+Language: Cpp
+Standard: Cpp11
+
+AccessModifierOffset: -1
+AlignEscapedNewlines: Left
+AlwaysBreakAfterReturnType: None
+AlwaysBreakTemplateDeclarations: Yes
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortFunctionsOnASingleLine: Inline
+BinPackParameters: false
+BreakBeforeBinaryOperators: NonAssignment
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: AfterColon
+BreakInheritanceList: AfterColon
+ColumnLimit: 120
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ContinuationIndentWidth: 4
+DerivePointerAlignment: false
+IndentCaseLabels: true
+IndentPPDirectives: None
+IndentWidth: 4
+MaxEmptyLinesToKeep: 1
+PointerAlignment: Left
+ReflowComments: true
+SortIncludes: false
+SortUsingDeclarations: true
+SpaceAfterTemplateKeyword: false
+SpacesBeforeTrailingComments: 2
+TabWidth: 4
+UseTab: Never
--- a/.gitignore
+++ b/.gitignore
@ -1,3 +1,4 @@
 __pycache__
 /target
+/nac3standalone/demo/linalg/target
 nix/windows/msys2
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@ -8,17 +8,17 @@ repos:
    hooks:
      - id: nac3-cargo-fmt
        name: nac3 cargo format
-        entry: cargo
+        entry: nix
        language: system
        types: [file, rust]
        pass_filenames: false
        description: Runs cargo fmt on the codebase.
-        args: [fmt]
+        args: [develop, -c, cargo, fmt, --all]
      - id: nac3-cargo-clippy
        name: nac3 cargo clippy
-        entry: cargo
+        entry: nix
        language: system
        types: [file, rust]
        pass_filenames: false
        description: Runs cargo clippy on the codebase.
-        args: [clippy, --tests]
+        args: [develop, -c, cargo, clippy, --tests]
--- a/Cargo.lock
+++ b/Cargo.lock
@ -26,9 +26,9 @@ dependencies = [

 [[package]]
 name = "anstream"
-version = "0.6.14"
+version = "0.6.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "418c75fa768af9c03be99d17643f93f79bbba589895012a80e3452a19ddda15b"
+checksum = "23a1e53f0f5d86382dafe1cf314783b2044280f406e7e1506368220ad11b1338"
 dependencies = [
 "anstyle",
 "anstyle-parse",
@ -41,67 +41,67 @@ dependencies = [

 [[package]]
 name = "anstyle"
-version = "1.0.7"
+version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "038dfcf04a5feb68e9c60b21c9625a54c2c0616e79b72b0fd87075a056ae1d1b"
+checksum = "8365de52b16c035ff4fcafe0092ba9390540e3e352870ac09933bebcaa2c8c56"

 [[package]]
 name = "anstyle-parse"
-version = "0.2.4"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c03a11a9034d92058ceb6ee011ce58af4a9bf61491aa7e1e59ecd24bd40d22d4"
+checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9"
 dependencies = [
 "utf8parse",
 ]

 [[package]]
 name = "anstyle-query"
-version = "1.1.0"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad186efb764318d35165f1758e7dcef3b10628e26d41a44bc5550652e6804391"
+checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.59.0",
 ]

 [[package]]
 name = "anstyle-wincon"
-version = "3.0.3"
+version = "3.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61a38449feb7068f52bb06c12759005cf459ee52bb4adc1d5a7c4322d716fb19"
+checksum = "2109dbce0e72be3ec00bed26e6a7479ca384ad226efdd66db8fa2e3a38c83125"
 dependencies = [
 "anstyle",
- "windows-sys",
+ "windows-sys 0.59.0",
 ]

 [[package]]
 name = "ascii-canvas"
-version = "3.0.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8824ecca2e851cec16968d54a01dd372ef8f95b244fb84b84e70128be347c3c6"
+checksum = "ef1e3e699d84ab1b0911a1010c5c106aa34ae89aeac103be5ce0c3859db1e891"
 dependencies = [
 "term",
 ]

 [[package]]
 name = "autocfg"
-version = "1.3.0"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
+checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"

 [[package]]
 name = "bit-set"
-version = "0.5.3"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1"
+checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
 dependencies = [
 "bit-vec",
 ]

 [[package]]
 name = "bit-vec"
-version = "0.6.3"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"

 [[package]]
 name = "bitflags"
@ -109,6 +109,15 @@ version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"

+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "byteorder"
 version = "1.5.0"
@ -117,9 +126,12 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"

 [[package]]
 name = "cc"
-version = "1.1.0"
+version = "1.1.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eaff6f8ce506b9773fa786672d63fc7a191ffea1be33f72bbd4aeacefca9ffc8"
+checksum = "c2e7962b54006dcfcc61cb72735f4d89bb97061dd6a7ed882ec6b8ee53714c6f"
+dependencies = [
+ "shlex",
+]

 [[package]]
 name = "cfg-if"
@ -129,9 +141,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

 [[package]]
 name = "clap"
-version = "4.5.9"
+version = "4.5.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64acc1846d54c1fe936a78dc189c34e28d3f5afc348403f28ecf53660b9b8462"
+checksum = "b97f376d85a664d5837dbae44bf546e6477a679ff6610010f17276f686d867e8"
 dependencies = [
 "clap_builder",
 "clap_derive",
@ -139,9 +151,9 @@ dependencies = [

 [[package]]
 name = "clap_builder"
-version = "4.5.9"
+version = "4.5.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fb8393d67ba2e7bfaf28a23458e4e2b543cc73a99595511eb207fdb8aede942"
+checksum = "19bc80abd44e4bed93ca373a0704ccbd1b710dc5749406201bb018272808dc54"
 dependencies = [
 "anstream",
 "anstyle",
@ -151,27 +163,27 @@ dependencies = [

 [[package]]
 name = "clap_derive"
-version = "4.5.8"
+version = "4.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bac35c6dafb060fd4d275d9a4ffae97917c13a6327903a8be2153cd964f7085"
+checksum = "4ac6a0c7b1a9e9a5186361f67dfa1b88213572f427fb9ab038efb2bd8c582dab"
 dependencies = [
 "heck 0.5.0",
 "proc-macro2",
 "quote",
- "syn 2.0.70",
+ "syn 2.0.85",
 ]

 [[package]]
 name = "clap_lex"
-version = "0.7.1"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b82cf0babdbd58558212896d1a4272303a57bdb245c2bf1147185fb45640e70"
+checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97"

 [[package]]
 name = "colorchoice"
-version = "1.0.1"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b6a852b24ab71dffc585bcb46eaf7959d175cb865a7152e35b348d1b2960422"
+checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"

 [[package]]
 name = "console"
@ -182,7 +194,16 @@ dependencies = [
 "encode_unicode",
 "lazy_static",
 "libc",
- "windows-sys",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
+dependencies = [
+ "libc",
 ]

 [[package]]
@ -242,30 +263,23 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"

 [[package]]
-name = "crunchy"
-version = "0.2.2"
+name = "crypto-common"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
-
-[[package]]
-name = "dirs-next"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
 dependencies = [
- "cfg-if",
- "dirs-sys-next",
+ "generic-array",
+ "typenum",
 ]

 [[package]]
-name = "dirs-sys-next"
-version = "0.1.2"
+name = "digest"
+version = "0.10.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 dependencies = [
- "libc",
- "redox_users",
- "winapi",
+ "block-buffer",
+ "crypto-common",
 ]

 [[package]]
@ -302,14 +316,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
 dependencies = [
 "libc",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]

 [[package]]
 name = "fastrand"
-version = "2.1.0"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fc0510504f03c51ada170672ac806f1f105a88aa97a5281117e1ddc3368e51a"
+checksum = "e8c02a5121d4ea3eb16a80748c74f5549a5665e4c21333c6098f283870fbdea6"

 [[package]]
 name = "fixedbitset"
@ -326,6 +340,16 @@ dependencies = [
 "byteorder",
 ]

+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
 [[package]]
 name = "getopts"
 version = "0.2.21"
@ -361,6 +385,12 @@ dependencies = [
 "ahash",
 ]

+[[package]]
+name = "hashbrown"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e087f84d4f86bf4b218b927129862374b72199ae7d8657835f1e89000eea4fb"
+
 [[package]]
 name = "heck"
 version = "0.4.1"
@ -373,6 +403,15 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"

+[[package]]
+name = "home"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
+dependencies = [
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "indexmap"
 version = "1.9.3"
@ -385,12 +424,12 @@ dependencies = [

 [[package]]
 name = "indexmap"
-version = "2.2.6"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
+checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da"
 dependencies = [
 "equivalent",
- "hashbrown 0.14.5",
+ "hashbrown 0.15.0",
 ]

 [[package]]
@ -401,9 +440,9 @@ checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5"

 [[package]]
 name = "inkwell"
-version = "0.4.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b597a7b2cdf279aeef6d7149071e35e4bc87c2cf05a5b7f2d731300bffe587ea"
+checksum = "40fb405537710d51f6bdbc8471365ddd4cd6d3a3c3ad6e0c8291691031ba94b2"
 dependencies = [
 "either",
 "inkwell_internals",
@ -415,13 +454,13 @@ dependencies = [

 [[package]]
 name = "inkwell_internals"
-version = "0.9.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fa4d8d74483041a882adaa9a29f633253a66dde85055f0495c121620ac484b2"
+checksum = "9dd28cfd4cfba665d47d31c08a6ba637eed16770abca2eccbbc3ca831fef1e44"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.70",
+ "syn 2.0.85",
 ]

 [[package]]
@ -440,18 +479,9 @@ dependencies = [

 [[package]]
 name = "is_terminal_polyfill"
-version = "1.70.0"
+version = "1.70.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8478577c03552c21db0e2724ffb8986a5ce7af88107e6be5d2ee6e158c12800"
-
-[[package]]
-name = "itertools"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57"
-dependencies = [
- "either",
-]
+checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"

 [[package]]
 name = "itertools"
@ -469,34 +499,44 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"

 [[package]]
-name = "lalrpop"
-version = "0.20.2"
+name = "keccak"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55cb077ad656299f160924eb2912aa147d7339ea7d69e1b5517326fdcec3c1ca"
+checksum = "ecc2af9a1119c51f12a14607e783cb977bde58bc069ff0c3da1095e635d70654"
+dependencies = [
+ "cpufeatures",
+]
+
+[[package]]
+name = "lalrpop"
+version = "0.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06093b57658c723a21da679530e061a8c25340fa5a6f98e313b542268c7e2a1f"
 dependencies = [
 "ascii-canvas",
 "bit-set",
 "ena",
- "itertools 0.11.0",
+ "itertools",
 "lalrpop-util",
 "petgraph",
 "pico-args",
 "regex",
 "regex-syntax",
+ "sha3",
 "string_cache",
 "term",
- "tiny-keccak",
 "unicode-xid",
 "walkdir",
 ]

 [[package]]
 name = "lalrpop-util"
-version = "0.20.2"
+version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "507460a910eb7b32ee961886ff48539633b788a36b65692b95f225b844c82553"
+checksum = "feee752d43abd0f4807a921958ab4131f692a44d4d599733d4419c5d586176ce"
 dependencies = [
 "regex-automata",
+ "rustversion",
 ]

 [[package]]
@ -507,30 +547,20 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"

 [[package]]
 name = "libc"
-version = "0.2.155"
+version = "0.2.161"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+checksum = "8e9489c2807c139ffd9c1794f4af0ebe86a828db53ecdc7fea2111d0fed085d1"

 [[package]]
 name = "libloading"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e310b3a6b5907f99202fcdb4960ff45b93735d7c7d96b760fcff8db2dc0e103d"
+checksum = "4979f22fdb869068da03c9f7528f8297c6fd2606bc3a4affe42e6a823fdb8da4"
 dependencies = [
 "cfg-if",
 "windows-targets",
 ]

-[[package]]
-name = "libredox"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
-dependencies = [
- "bitflags",
- "libc",
-]
-
 [[package]]
 name = "linked-hash-map"
 version = "0.5.6"
@ -591,11 +621,9 @@ dependencies = [
 name = "nac3artiq"
 version = "0.1.0"
 dependencies = [
- "inkwell",
- "itertools 0.13.0",
+ "itertools",
 "nac3core",
 "nac3ld",
- "nac3parser",
 "parking_lot",
 "pyo3",
 "tempfile",
@ -606,7 +634,6 @@ name = "nac3ast"
 version = "0.1.0"
 dependencies = [
 "fxhash",
- "lazy_static",
 "parking_lot",
 "string-interner",
 ]
@ -616,11 +643,11 @@ name = "nac3core"
 version = "0.1.0"
 dependencies = [
 "crossbeam",
- "indexmap 2.2.6",
+ "indexmap 2.6.0",
 "indoc",
 "inkwell",
 "insta",
- "itertools 0.13.0",
+ "itertools",
 "nac3parser",
 "parking_lot",
 "rayon",
@ -658,9 +685,7 @@ name = "nac3standalone"
 version = "0.1.0"
 dependencies = [
 "clap",
- "inkwell",
 "nac3core",
- "nac3parser",
 "parking_lot",
 ]

@ -672,9 +697,9 @@ checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"

 [[package]]
 name = "once_cell"
-version = "1.19.0"
+version = "1.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"

 [[package]]
 name = "parking_lot"
@ -706,7 +731,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
 dependencies = [
 "fixedbitset",
- "indexmap 2.2.6",
+ "indexmap 2.6.0",
 ]

 [[package]]
@ -749,7 +774,7 @@ dependencies = [
 "phf_shared 0.11.2",
 "proc-macro2",
 "quote",
- "syn 2.0.70",
+ "syn 2.0.85",
 ]

 [[package]]
@ -778,15 +803,18 @@ checksum = "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315"

 [[package]]
 name = "portable-atomic"
-version = "1.6.0"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7170ef9988bc169ba16dd36a7fa041e5c4cbeb6a35b76d4c03daded371eae7c0"
+checksum = "cc9c68a3f6da06753e9335d63e27f6b9754dd1920d941135b7ea8224f141adb2"

 [[package]]
 name = "ppv-lite86"
-version = "0.2.17"
+version = "0.2.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
+dependencies = [
+ "zerocopy",
+]

 [[package]]
 name = "precomputed-hash"
@ -796,9 +824,9 @@ checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"

 [[package]]
 name = "proc-macro2"
-version = "1.0.86"
+version = "1.0.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e"
 dependencies = [
 "unicode-ident",
 ]
@ -850,7 +878,7 @@ dependencies = [
 "proc-macro2",
 "pyo3-macros-backend",
 "quote",
- "syn 2.0.70",
+ "syn 2.0.85",
 ]

 [[package]]
@ -863,14 +891,14 @@ dependencies = [
 "proc-macro2",
 "pyo3-build-config",
 "quote",
- "syn 2.0.70",
+ "syn 2.0.85",
 ]

 [[package]]
 name = "quote"
-version = "1.0.36"
+version = "1.0.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
 dependencies = [
 "proc-macro2",
 ]
@ -927,29 +955,18 @@ dependencies = [

 [[package]]
 name = "redox_syscall"
-version = "0.5.2"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c82cf8cff14456045f55ec4241383baeff27af886adb72ffb2162f99911de0fd"
+checksum = "9b6dfecf2c74bce2466cabf93f6664d6998a69eb21e39f4207930065b27b771f"
 dependencies = [
 "bitflags",
 ]

-[[package]]
-name = "redox_users"
-version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd283d9651eeda4b2a83a43c1c91b266c40fd76ecd39a50a8c630ae69dc72891"
-dependencies = [
- "getrandom",
- "libredox",
- "thiserror",
-]
-
 [[package]]
 name = "regex"
-version = "1.10.5"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b91213439dad192326a0d7c6ee3955910425f441d7038e0d6933b0aec5c4517f"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
 dependencies = [
 "aho-corasick",
 "memchr",
@ -959,9 +976,9 @@ dependencies = [

 [[package]]
 name = "regex-automata"
-version = "0.4.7"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df"
+checksum = "368758f23274712b504848e9d5a6f010445cc8b87a7cdb4d7cbee666c1288da3"
 dependencies = [
 "aho-corasick",
 "memchr",
@ -970,9 +987,9 @@ dependencies = [

 [[package]]
 name = "regex-syntax"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"

 [[package]]
 name = "runkernel"
@ -983,22 +1000,22 @@ dependencies = [

 [[package]]
 name = "rustix"
-version = "0.38.34"
+version = "0.38.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
+checksum = "aa260229e6538e52293eeb577aabd09945a09d6d9cc0fc550ed7529056c2e32a"
 dependencies = [
 "bitflags",
 "errno",
 "libc",
 "linux-raw-sys",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]

 [[package]]
 name = "rustversion"
-version = "1.0.17"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6"
+checksum = "0e819f2bc632f285be6d7cd36e25940d45b2391dd6d9b939e79de557f7014248"

 [[package]]
 name = "ryu"
@ -1029,31 +1046,32 @@ checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"

 [[package]]
 name = "serde"
-version = "1.0.204"
+version = "1.0.214"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc76f558e0cbb2a839d37354c575f1dc3fdc6546b5be373ba43d95f231bf7c12"
+checksum = "f55c3193aca71c12ad7890f1785d2b73e1b9f63a0bbc353c08ef26fe03fc56b5"
 dependencies = [
 "serde_derive",
 ]

 [[package]]
 name = "serde_derive"
-version = "1.0.204"
+version = "1.0.214"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0cd7e117be63d3c3678776753929474f3b04a43a080c744d6b0ae2a8c28e222"
+checksum = "de523f781f095e28fa605cdce0f8307e451cc0fd14e2eb4cd2e98a355b147766"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.70",
+ "syn 2.0.85",
 ]

 [[package]]
 name = "serde_json"
-version = "1.0.120"
+version = "1.0.132"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e0d21c9a8cae1235ad58a00c11cb40d4b1e5c784f1ef2c537876ed6ffd8b7c5"
+checksum = "d726bfaff4b320266d395898905d0eba0345aae23b54aee3a737e260fd46db03"
 dependencies = [
 "itoa",
+ "memchr",
 "ryu",
 "serde",
 ]
@ -1071,10 +1089,26 @@ dependencies = [
 ]

 [[package]]
-name = "similar"
-version = "2.5.0"
+name = "sha3"
+version = "0.10.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa42c91313f1d05da9b26f267f931cf178d4aba455b4c4622dd7355eb80c6640"
+checksum = "75872d278a8f37ef87fa0ddbda7802605cb18344497949862c0d4dcb291eba60"
+dependencies = [
+ "digest",
+ "keccak",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "similar"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1de1d4f81173b03af4c0cbed3c898f6bff5b870e4a7f5d6f4057d62a7a4b686e"

 [[package]]
 name = "siphasher"
@ -1134,7 +1168,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "rustversion",
- "syn 2.0.70",
+ "syn 2.0.85",
 ]

 [[package]]
@ -1150,9 +1184,9 @@ dependencies = [

 [[package]]
 name = "syn"
-version = "2.0.70"
+version = "2.0.85"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f0209b68b3613b093e0ec905354eccaedcfe83b8cb37cbdeae64026c3064c16"
+checksum = "5023162dfcd14ef8f32034d8bcd4cc5ddc61ef7a247c024a33e24e1f24d21b56"
 dependencies = [
 "proc-macro2",
 "quote",
@ -1161,31 +1195,31 @@ dependencies = [

 [[package]]
 name = "target-lexicon"
-version = "0.12.15"
+version = "0.12.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4873307b7c257eddcb50c9bedf158eb669578359fb28428bef438fec8e6ba7c2"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"

 [[package]]
 name = "tempfile"
-version = "3.10.1"
+version = "3.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
+checksum = "f0f2c9fc62d0beef6951ccffd757e241266a2c833136efbe35af6cd2567dca5b"
 dependencies = [
 "cfg-if",
 "fastrand",
+ "once_cell",
 "rustix",
- "windows-sys",
+ "windows-sys 0.59.0",
 ]

 [[package]]
 name = "term"
-version = "0.7.0"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c59df8ac95d96ff9bede18eb7300b0fda5e5d8d90960e76f8e14ae765eedbf1f"
+checksum = "4df4175de05129f31b80458c6df371a15e7fc3fd367272e6bf938e5c351c7ea0"
 dependencies = [
- "dirs-next",
- "rustversion",
- "winapi",
+ "home",
+ "windows-sys 0.52.0",
 ]

 [[package]]
@ -1203,32 +1237,29 @@ dependencies = [

 [[package]]
 name = "thiserror"
-version = "1.0.61"
+version = "1.0.65"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709"
+checksum = "5d11abd9594d9b38965ef50805c5e469ca9cc6f197f883f717e0269a3057b3d5"
 dependencies = [
 "thiserror-impl",
 ]

 [[package]]
 name = "thiserror-impl"
-version = "1.0.61"
+version = "1.0.65"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
+checksum = "ae71770322cbd277e69d762a16c444af02aa0575ac0d174f0b9562d3b37f8602"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.70",
+ "syn 2.0.85",
 ]

 [[package]]
-name = "tiny-keccak"
-version = "2.0.2"
+name = "typenum"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
-dependencies = [
- "crunchy",
-]
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"

 [[package]]
 name = "unic-char-property"
@ -1284,27 +1315,27 @@ dependencies = [

 [[package]]
 name = "unicode-ident"
-version = "1.0.12"
+version = "1.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"

 [[package]]
 name = "unicode-width"
-version = "0.1.13"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0336d538f7abc86d282a4189614dfaa90810dfc2c6f6427eaf88e16311dd225d"
+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"

 [[package]]
 name = "unicode-xid"
-version = "0.2.4"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"

 [[package]]
 name = "unicode_names2"
-version = "1.2.2"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "addeebf294df7922a1164f729fb27ebbbcea99cc32b3bf08afab62757f707677"
+checksum = "d1673eca9782c84de5f81b82e4109dcfb3611c8ba0d52930ec4a9478f547b2dd"
 dependencies = [
 "phf",
 "unicode_names2_generator",
@ -1312,9 +1343,9 @@ dependencies = [

 [[package]]
 name = "unicode_names2_generator"
-version = "1.2.2"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f444b8bba042fe3c1251ffaca35c603f2dc2ccc08d595c65a8c4f76f3e8426c0"
+checksum = "b91e5b84611016120197efd7dc93ef76774f4e084cd73c9fb3ea4a86c570c56e"
 dependencies = [
 "getopts",
 "log",
@ -1336,9 +1367,9 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"

 [[package]]
 name = "version_check"
-version = "0.9.4"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"

 [[package]]
 name = "walkdir"
@ -1356,37 +1387,15 @@ version = "0.11.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"

-[[package]]
-name = "winapi"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
-dependencies = [
- "winapi-i686-pc-windows-gnu",
- "winapi-x86_64-pc-windows-gnu",
-]
-
-[[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
-
 [[package]]
 name = "winapi-util"
-version = "0.1.8"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"
+checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.59.0",
 ]

-[[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
-
 [[package]]
 name = "windows-sys"
 version = "0.52.0"
@ -1396,6 +1405,15 @@ dependencies = [
 "windows-targets",
 ]

+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.52.6"
@ -1475,6 +1493,7 @@ version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
 dependencies = [
+ "byteorder",
 "zerocopy-derive",
 ]

@ -1486,5 +1505,5 @@ checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.70",
+ "syn 2.0.85",
 ]
--- a/flake.lock
+++ b/flake.lock
@ -2,11 +2,11 @@
  "nodes": {
    "nixpkgs": {
      "locked": {
-        "lastModified": 1720418205,
-        "narHash": "sha256-cPJoFPXU44GlhWg4pUk9oUPqurPlCFZ11ZQPk21GTPU=",
+        "lastModified": 1727348695,
+        "narHash": "sha256-J+PeFKSDV+pHL7ukkfpVzCOO7mBSrrpJ3svwBFABbhI=",
        "owner": "NixOS",
        "repo": "nixpkgs",
-        "rev": "655a58a72a6601292512670343087c2d75d859c1",
+        "rev": "1925c603f17fc89f4c8f6bf6f631a802ad85d784",
        "type": "github"
      },
      "original": {
--- a/flake.nix
+++ b/flake.nix
@ -6,6 +6,7 @@
  outputs = { self, nixpkgs }:
    let
      pkgs = import nixpkgs { system = "x86_64-linux"; };
+      pkgs32 = import nixpkgs { system = "i686-linux"; };
    in rec {
      packages.x86_64-linux = rec {
        llvm-nac3 = pkgs.callPackage ./nix/llvm {};
@ -13,9 +14,24 @@
          ''
          mkdir -p $out/bin
          ln -s ${pkgs.llvmPackages_14.clang-unwrapped}/bin/clang $out/bin/clang-irrt
-          ln -s ${pkgs.llvmPackages_14.clang}/bin/clang $out/bin/clang-irrt-test
          ln -s ${pkgs.llvmPackages_14.llvm.out}/bin/llvm-as $out/bin/llvm-as-irrt
          '';
+        demo-linalg-stub = pkgs.rustPlatform.buildRustPackage {
+          name = "demo-linalg-stub";
+          src = ./nac3standalone/demo/linalg;
+          cargoLock = {
+            lockFile = ./nac3standalone/demo/linalg/Cargo.lock;
+          };
+          doCheck = false;
+        };
+        demo-linalg-stub32 = pkgs32.rustPlatform.buildRustPackage {
+          name = "demo-linalg-stub32";
+          src = ./nac3standalone/demo/linalg;
+          cargoLock = {
+            lockFile = ./nac3standalone/demo/linalg/Cargo.lock;
+          };
+          doCheck = false;
+        };
        nac3artiq = pkgs.python3Packages.toPythonModule (
          pkgs.rustPlatform.buildRustPackage rec {
            name = "nac3artiq";
@ -24,9 +40,8 @@
            cargoLock = {
              lockFile = ./Cargo.lock;
            };
-            cargoTestFlags = [ "--features" "test" ];
            passthru.cargoLock = cargoLock;
-            nativeBuildInputs = [ pkgs.python3 pkgs.llvmPackages_14.clang llvm-tools-irrt pkgs.llvmPackages_14.llvm.out llvm-nac3 ];
+            nativeBuildInputs = [ pkgs.python3 (pkgs.wrapClangMulti pkgs.llvmPackages_14.clang) llvm-tools-irrt pkgs.llvmPackages_14.llvm.out llvm-nac3 ];
            buildInputs = [ pkgs.python3 llvm-nac3 ];
            checkInputs = [ (pkgs.python3.withPackages(ps: [ ps.numpy ps.scipy ])) ];
            checkPhase =
@ -34,7 +49,9 @@
              echo "Checking nac3standalone demos..."
              pushd nac3standalone/demo
              patchShebangs .
-              ./check_demos.sh
+              export DEMO_LINALG_STUB=${demo-linalg-stub}/lib/liblinalg.a
+              export DEMO_LINALG_STUB32=${demo-linalg-stub32}/lib/liblinalg.a
+              ./check_demos.sh -i686
              popd
              echo "Running Cargo tests..."
              cargoCheckHook
@ -151,7 +168,7 @@
        buildInputs = with pkgs; [
          # build dependencies
          packages.x86_64-linux.llvm-nac3
-          llvmPackages_14.clang llvmPackages_14.llvm.out  # for running nac3standalone demos
+          (pkgs.wrapClangMulti llvmPackages_14.clang) llvmPackages_14.llvm.out  # for running nac3standalone demos
          packages.x86_64-linux.llvm-tools-irrt
          cargo
          rustc
@ -163,10 +180,12 @@
          clippy
          pre-commit
          rustfmt
-          rust-analyzer
        ];
-        # https://nixos.wiki/wiki/Rust#Shell.nix_example
-        RUST_SRC_PATH = "${pkgs.rust.packages.stable.rustPlatform.rustLibSrc}";
+        shellHook =
+          ''
+          export DEMO_LINALG_STUB=${packages.x86_64-linux.demo-linalg-stub}/lib/liblinalg.a
+          export DEMO_LINALG_STUB32=${packages.x86_64-linux.demo-linalg-stub32}/lib/liblinalg.a
+          '';
      };
      devShells.x86_64-linux.msys2 = pkgs.mkShell {
        name = "nac3-dev-shell-msys2";
--- a/nac3artiq/Cargo.toml
+++ b/nac3artiq/Cargo.toml
@ -12,15 +12,10 @@ crate-type = ["cdylib"]
 itertools = "0.13"
 pyo3 = { version = "0.21", features = ["extension-module", "gil-refs"] }
 parking_lot = "0.12"
-tempfile = "3.10"
-nac3parser = { path = "../nac3parser" }
+tempfile = "3.13"
 nac3core = { path = "../nac3core" }
 nac3ld = { path = "../nac3ld" }

-[dependencies.inkwell]
-version = "0.4"
-default-features = false
-features = ["llvm14-0", "target-x86", "target-arm", "target-riscv", "no-libffi-linking"]
-
 [features]
 init-llvm-profile = []
+no-escape-analysis = ["nac3core/no-escape-analysis"]
--- a/nac3artiq/demo/list_cmp.py
+++ b/nac3artiq/demo/list_cmp.py
@ -0,0 +1,24 @@
+from min_artiq import *
+from numpy import int32
+
+
+@nac3
+class EmptyList:
+    core: KernelInvariant[Core]
+
+    def __init__(self):
+        self.core = Core()
+
+    @rpc
+    def get_empty(self) -> list[int32]:
+        return []
+
+    @kernel
+    def run(self):
+        a: list[int32] = self.get_empty()
+        if a != []:
+            raise ValueError
+
+
+if __name__ == "__main__":
+    EmptyList().run()
--- a/nac3artiq/demo/min_artiq.py
+++ b/nac3artiq/demo/min_artiq.py
@ -112,10 +112,15 @@ def extern(function):
    register_function(function)
    return function

-def rpc(function):
-    """Decorates a function declaration defined by the core device runtime."""
-    register_function(function)
-    return function
+
+def rpc(arg=None, flags={}):
+    """Decorates a function or method to be executed on the host interpreter."""
+    if arg is None:
+        def inner_decorator(function):
+            return rpc(function, flags)
+        return inner_decorator
+    register_function(arg)
+    return arg

 def kernel(function_or_method):
    """Decorates a function or method to be executed on the core device."""
--- a/nac3artiq/demo/str_abi.py
+++ b/nac3artiq/demo/str_abi.py
@ -0,0 +1,26 @@
+from min_artiq import *
+from numpy import ndarray, zeros as np_zeros
+
+
+@nac3
+class StrFail:
+    core: KernelInvariant[Core]
+
+    def __init__(self):
+        self.core = Core()
+
+    @kernel
+    def hello(self, arg: str):
+        pass
+
+    @kernel
+    def consume_ndarray(self, arg: ndarray[str, 1]):
+        pass
+
+    def run(self):
+        self.hello("world")
+        self.consume_ndarray(np_zeros([10], dtype=str))
+
+
+if __name__ == "__main__":
+    StrFail().run()
--- a/nac3artiq/src/codegen.rs
+++ b/nac3artiq/src/codegen.rs
--- a/nac3artiq/src/lib.rs
+++ b/nac3artiq/src/lib.rs
@ -16,63 +16,65 @@
    clippy::wildcard_imports
 )]

-use std::collections::{HashMap, HashSet};
-use std::fs;
-use std::io::Write;
-use std::process::Command;
-use std::rc::Rc;
-use std::sync::Arc;
+use std::{
+    collections::{HashMap, HashSet},
+    fs,
+    io::Write,
+    process::Command,
+    rc::Rc,
+    sync::Arc,
+};

-use inkwell::{
+use itertools::Itertools;
+use parking_lot::{Mutex, RwLock};
+use pyo3::{
+    create_exception, exceptions,
+    prelude::*,
+    types::{PyBytes, PyDict, PySet},
+};
+use tempfile::{self, TempDir};
+
+use nac3core::{
+    codegen::{
+        concrete_type::ConcreteTypeStore, gen_func_impl, irrt::load_irrt, CodeGenLLVMOptions,
+        CodeGenTargetMachineOptions, CodeGenTask, WithCall, WorkerRegistry,
+    },
+    inkwell::{
+        context::Context,
        memory_buffer::MemoryBuffer,
        module::{Linkage, Module},
        passes::PassBuilderOptions,
        support::is_multithreaded,
        targets::*,
        OptimizationLevel,
-};
-use itertools::Itertools;
-use nac3core::codegen::{gen_func_impl, CodeGenLLVMOptions, CodeGenTargetMachineOptions};
-use nac3core::toplevel::builtins::get_exn_constructor;
-use nac3core::typecheck::typedef::{TypeEnum, Unifier, VarMap};
-use nac3parser::{
-    ast::{ExprKind, Stmt, StmtKind, StrRef},
+    },
+    nac3parser::{
+        ast::{Constant, ExprKind, Located, Stmt, StmtKind, StrRef},
        parser::parse_program,
-};
-use pyo3::create_exception;
-use pyo3::prelude::*;
-use pyo3::{exceptions, types::PyBytes, types::PyDict, types::PySet};
-
-use parking_lot::{Mutex, RwLock};
-
-use nac3core::{
-    codegen::irrt::load_irrt,
-    codegen::{concrete_type::ConcreteTypeStore, CodeGenTask, WithCall, WorkerRegistry},
+    },
    symbol_resolver::SymbolResolver,
    toplevel::{
-        composer::{ComposerConfig, TopLevelComposer},
+        builtins::get_exn_constructor,
+        composer::{BuiltinFuncCreator, BuiltinFuncSpec, ComposerConfig, TopLevelComposer},
        DefinitionId, GenCall, TopLevelDef,
    },
-    typecheck::typedef::{FunSignature, FuncArg},
-    typecheck::{type_inferencer::PrimitiveStore, typedef::Type},
+    typecheck::{
+        type_inferencer::PrimitiveStore,
+        typedef::{into_var_map, FunSignature, FuncArg, Type, TypeEnum, Unifier, VarMap},
+    },
 };
-
 use nac3ld::Linker;

-use tempfile::{self, TempDir};
-
-use crate::codegen::attributes_writeback;
-use crate::{
-    codegen::{rpc_codegen_callback, ArtiqCodeGenerator},
-    symbol_resolver::{DeferredEvaluationStore, InnerResolver, PythonHelper, Resolver},
+use codegen::{
+    attributes_writeback, gen_core_log, gen_rtio_log, rpc_codegen_callback, ArtiqCodeGenerator,
 };
+use symbol_resolver::{DeferredEvaluationStore, InnerResolver, PythonHelper, Resolver};
+use timeline::TimeFns;

 mod codegen;
 mod symbol_resolver;
 mod timeline;

-use timeline::TimeFns;
-
 #[derive(PartialEq, Clone, Copy)]
 enum Isa {
    Host,
@ -126,7 +128,7 @@ struct Nac3 {
    isa: Isa,
    time_fns: &'static (dyn TimeFns + Sync),
    primitive: PrimitiveStore,
-    builtins: Vec<(StrRef, FunSignature, Arc<GenCall>)>,
+    builtins: Vec<BuiltinFuncSpec>,
    pyid_to_def: Arc<RwLock<HashMap<u64, DefinitionId>>>,
    primitive_ids: PrimitivePythonId,
    working_directory: TempDir,
@ -193,10 +195,8 @@ impl Nac3 {
                    body.retain(|stmt| {
                        if let StmtKind::FunctionDef { ref decorator_list, .. } = stmt.node {
                            decorator_list.iter().any(|decorator| {
-                                if let ExprKind::Name { id, .. } = decorator.node {
-                                    id.to_string() == "kernel"
-                                        || id.to_string() == "portable"
-                                        || id.to_string() == "rpc"
+                                if let Some(id) = decorator_id_string(decorator) {
+                                    id == "kernel" || id == "portable" || id == "rpc"
                                } else {
                                    false
                                }
@ -209,9 +209,8 @@ impl Nac3 {
                }
                StmtKind::FunctionDef { ref decorator_list, .. } => {
                    decorator_list.iter().any(|decorator| {
-                        if let ExprKind::Name { id, .. } = decorator.node {
-                            let id = id.to_string();
-                            id == "extern" || id == "portable" || id == "kernel" || id == "rpc"
+                        if let Some(id) = decorator_id_string(decorator) {
+                            id == "extern" || id == "kernel" || id == "portable" || id == "rpc"
                        } else {
                            false
                        }
@ -264,7 +263,7 @@ impl Nac3 {
                    arg_names.len(),
                ));
            }
-            for (i, FuncArg { ty, default_value, name }) in args.iter().enumerate() {
+            for (i, FuncArg { ty, default_value, name, .. }) in args.iter().enumerate() {
                let in_name = match arg_names.get(i) {
                    Some(n) => n,
                    None if default_value.is_none() => {
@ -300,6 +299,64 @@ impl Nac3 {
        None
    }

+    /// Returns a [`Vec`] of builtins that needs to be initialized during method compilation time.
+    fn get_lateinit_builtins() -> Vec<Box<BuiltinFuncCreator>> {
+        vec![
+            Box::new(|primitives, unifier| {
+                let arg_ty = unifier.get_fresh_var(Some("T".into()), None);
+
+                (
+                    "core_log".into(),
+                    FunSignature {
+                        args: vec![FuncArg {
+                            name: "arg".into(),
+                            ty: arg_ty.ty,
+                            default_value: None,
+                            is_vararg: false,
+                        }],
+                        ret: primitives.none,
+                        vars: into_var_map([arg_ty]),
+                    },
+                    Arc::new(GenCall::new(Box::new(move |ctx, obj, fun, args, generator| {
+                        gen_core_log(ctx, &obj, fun, &args, generator)?;
+
+                        Ok(None)
+                    }))),
+                )
+            }),
+            Box::new(|primitives, unifier| {
+                let arg_ty = unifier.get_fresh_var(Some("T".into()), None);
+
+                (
+                    "rtio_log".into(),
+                    FunSignature {
+                        args: vec![
+                            FuncArg {
+                                name: "channel".into(),
+                                ty: primitives.str,
+                                default_value: None,
+                                is_vararg: false,
+                            },
+                            FuncArg {
+                                name: "arg".into(),
+                                ty: arg_ty.ty,
+                                default_value: None,
+                                is_vararg: false,
+                            },
+                        ],
+                        ret: primitives.none,
+                        vars: into_var_map([arg_ty]),
+                    },
+                    Arc::new(GenCall::new(Box::new(move |ctx, obj, fun, args, generator| {
+                        gen_rtio_log(ctx, &obj, fun, &args, generator)?;
+
+                        Ok(None)
+                    }))),
+                )
+            }),
+        ]
+    }
+
    fn compile_method<T>(
        &self,
        obj: &PyAny,
@ -312,6 +369,7 @@ impl Nac3 {
        let size_t = self.isa.get_size_type();
        let (mut composer, mut builtins_def, mut builtins_ty) = TopLevelComposer::new(
            self.builtins.clone(),
+            Self::get_lateinit_builtins(),
            ComposerConfig { kernel_ann: Some("Kernel"), kernel_invariant_ann: "KernelInvariant" },
            size_t,
        );
@ -388,7 +446,6 @@ impl Nac3 {
                        pyid_to_type: pyid_to_type.clone(),
                        primitive_ids: self.primitive_ids.clone(),
                        global_value_ids: global_value_ids.clone(),
-                        class_names: Mutex::default(),
                        name_to_pyid: name_to_pyid.clone(),
                        module: module.clone(),
                        id_to_pyval: RwLock::default(),
@ -419,9 +476,25 @@ impl Nac3 {

            match &stmt.node {
                StmtKind::FunctionDef { decorator_list, .. } => {
-                    if decorator_list.iter().any(|decorator| matches!(decorator.node, ExprKind::Name { id, .. } if id == "rpc".into())) {
-                        store_fun.call1(py, (def_id.0.into_py(py), module.getattr(py, name.to_string().as_str()).unwrap())).unwrap();
-                        rpc_ids.push((None, def_id));
+                    if decorator_list
+                        .iter()
+                        .any(|decorator| decorator_id_string(decorator) == Some("rpc".to_string()))
+                    {
+                        store_fun
+                            .call1(
+                                py,
+                                (
+                                    def_id.0.into_py(py),
+                                    module.getattr(py, name.to_string().as_str()).unwrap(),
+                                ),
+                            )
+                            .unwrap();
+                        let is_async = decorator_list.iter().any(|decorator| {
+                            decorator_get_flags(decorator)
+                                .iter()
+                                .any(|constant| *constant == Constant::Str("async".into()))
+                        });
+                        rpc_ids.push((None, def_id, is_async));
                    }
                }
                StmtKind::ClassDef { name, body, .. } => {
@ -429,19 +502,26 @@ impl Nac3 {
                    let class_obj = module.getattr(py, class_name.as_str()).unwrap();
                    for stmt in body {
                        if let StmtKind::FunctionDef { name, decorator_list, .. } = &stmt.node {
-                            if decorator_list.iter().any(|decorator| matches!(decorator.node, ExprKind::Name { id, .. } if id == "rpc".into())) {
+                            if decorator_list.iter().any(|decorator| {
+                                decorator_id_string(decorator) == Some("rpc".to_string())
+                            }) {
+                                let is_async = decorator_list.iter().any(|decorator| {
+                                    decorator_get_flags(decorator)
+                                        .iter()
+                                        .any(|constant| *constant == Constant::Str("async".into()))
+                                });
                                if name == &"__init__".into() {
                                    return Err(CompileError::new_err(format!(
                                        "compilation failed\n----------\nThe constructor of class {} should not be decorated with rpc decorator (at {})",
                                        class_name, stmt.location
                                    )));
                                }
-                                rpc_ids.push((Some((class_obj.clone(), *name)), def_id));
+                                rpc_ids.push((Some((class_obj.clone(), *name)), def_id, is_async));
                            }
                        }
                    }
                }
-                _ => ()
+                _ => (),
            }

            let id = *name_to_pyid.get(&name).unwrap();
@ -480,7 +560,6 @@ impl Nac3 {
            pyid_to_type: pyid_to_type.clone(),
            primitive_ids: self.primitive_ids.clone(),
            global_value_ids: global_value_ids.clone(),
-            class_names: Mutex::default(),
            id_to_pyval: RwLock::default(),
            id_to_primitive: RwLock::default(),
            field_to_val: RwLock::default(),
@ -497,6 +576,10 @@ impl Nac3 {
            .register_top_level(synthesized.pop().unwrap(), Some(resolver.clone()), "", false)
            .unwrap();

+        // Process IRRT
+        let context = Context::create();
+        let irrt = load_irrt(&context, resolver.as_ref());
+
        let fun_signature =
            FunSignature { args: vec![], ret: self.primitive.none, vars: VarMap::new() };
        let mut store = ConcreteTypeStore::new();
@ -534,13 +617,12 @@ impl Nac3 {
        let top_level = Arc::new(composer.make_top_level_context());

        {
-            let rpc_codegen = rpc_codegen_callback();
            let defs = top_level.definitions.read();
-            for (class_data, id) in &rpc_ids {
+            for (class_data, id, is_async) in &rpc_ids {
                let mut def = defs[id.0].write();
                match &mut *def {
                    TopLevelDef::Function { codegen_callback, .. } => {
-                        *codegen_callback = Some(rpc_codegen.clone());
+                        *codegen_callback = Some(rpc_codegen_callback(*is_async));
                    }
                    TopLevelDef::Class { methods, .. } => {
                        let (class_def, method_name) = class_data.as_ref().unwrap();
@ -551,7 +633,7 @@ impl Nac3 {
                            if let TopLevelDef::Function { codegen_callback, .. } =
                                &mut *defs[id.0].write()
                            {
-                                *codegen_callback = Some(rpc_codegen.clone());
+                                *codegen_callback = Some(rpc_codegen_callback(*is_async));
                                store_fun
                                    .call1(
                                        py,
@ -566,6 +648,11 @@ impl Nac3 {
                            }
                        }
                    }
+                    TopLevelDef::Variable { .. } => {
+                        return Err(CompileError::new_err(String::from(
+                            "Unsupported @rpc annotation on global variable",
+                        )))
+                    }
                }
            }
        }
@ -625,7 +712,9 @@ impl Nac3 {
            let buffer = buffer.as_slice().into();
            membuffer.lock().push(buffer);
        })));
-        let size_t = if self.isa == Isa::Host { 64 } else { 32 };
+        let size_t = context
+            .ptr_sized_int_type(&self.get_llvm_target_machine().get_target_data(), None)
+            .get_bit_width();
        let num_threads = if is_multithreaded() { 4 } else { 1 };
        let thread_names: Vec<String> = (0..num_threads).map(|_| "main".to_string()).collect();
        let threads: Vec<_> = thread_names
@ -642,8 +731,11 @@ impl Nac3 {

            let mut generator =
                ArtiqCodeGenerator::new("attributes_writeback".to_string(), size_t, self.time_fns);
-            let context = inkwell::context::Context::create();
+            let context = Context::create();
            let module = context.create_module("attributes_writeback");
+            let target_machine = self.llvm_options.create_target_machine().unwrap();
+            module.set_data_layout(&target_machine.get_target_data().get_data_layout());
+            module.set_triple(&target_machine.get_triple());
            let builder = context.create_builder();
            let (_, module, _) = gen_func_impl(
                &context,
@ -662,7 +754,7 @@ impl Nac3 {
            membuffer.lock().push(buffer);
        });

-        let context = inkwell::context::Context::create();
+        // Link all modules into `main`.
        let buffers = membuffers.lock();
        let main = context
            .create_module_from_ir(MemoryBuffer::create_from_memory_range(&buffers[0], "main"))
@ -691,8 +783,7 @@ impl Nac3 {
            )
            .unwrap();

-        main.link_in_module(load_irrt(&context))
-            .map_err(|err| CompileError::new_err(err.to_string()))?;
+        main.link_in_module(irrt).map_err(|err| CompileError::new_err(err.to_string()))?;

        let mut function_iter = main.get_first_function();
        while let Some(func) = function_iter {
@ -778,6 +869,41 @@ impl Nac3 {
    }
 }

+/// Retrieves the Name.id from a decorator, supports decorators with arguments.
+fn decorator_id_string(decorator: &Located<ExprKind>) -> Option<String> {
+    if let ExprKind::Name { id, .. } = decorator.node {
+        // Bare decorator
+        return Some(id.to_string());
+    } else if let ExprKind::Call { func, .. } = &decorator.node {
+        // Decorators that are calls (e.g. "@rpc()") have Call for the node,
+        // need to extract the id from within.
+        if let ExprKind::Name { id, .. } = func.node {
+            return Some(id.to_string());
+        }
+    }
+    None
+}
+
+/// Retrieves flags from a decorator, if any.
+fn decorator_get_flags(decorator: &Located<ExprKind>) -> Vec<Constant> {
+    let mut flags = vec![];
+    if let ExprKind::Call { keywords, .. } = &decorator.node {
+        for keyword in keywords {
+            if keyword.node.arg != Some("flags".into()) {
+                continue;
+            }
+            if let ExprKind::Set { elts } = &keyword.node.value.node {
+                for elt in elts {
+                    if let ExprKind::Constant { value, .. } = &elt.node {
+                        flags.push(value.clone());
+                    }
+                }
+            }
+        }
+    }
+    flags
+}
+
 fn link_with_lld(elf_filename: String, obj_filename: String) -> PyResult<()> {
    let linker_args = vec![
        "-shared".to_string(),
@ -847,7 +973,7 @@ impl Nac3 {
            Isa::RiscV32IMA => &timeline::NOW_PINNING_TIME_FNS,
            Isa::CortexA9 | Isa::Host => &timeline::EXTERN_TIME_FNS,
        };
-        let primitive: PrimitiveStore = TopLevelComposer::make_primitives(isa.get_size_type()).0;
+        let (primitive, _) = TopLevelComposer::make_primitives(isa.get_size_type());
        let builtins = vec![
            (
                "now_mu".into(),
@ -863,6 +989,7 @@ impl Nac3 {
                        name: "t".into(),
                        ty: primitive.int64,
                        default_value: None,
+                        is_vararg: false,
                    }],
                    ret: primitive.none,
                    vars: VarMap::new(),
@ -882,6 +1009,7 @@ impl Nac3 {
                        name: "dt".into(),
                        ty: primitive.int64,
                        default_value: None,
+                        is_vararg: false,
                    }],
                    ret: primitive.none,
                    vars: VarMap::new(),
--- a/nac3artiq/src/symbol_resolver.rs
+++ b/nac3artiq/src/symbol_resolver.rs
@ -1,14 +1,30 @@
-use inkwell::{
-    types::{BasicType, BasicTypeEnum},
-    values::BasicValueEnum,
-    AddressSpace,
+use std::{
+    collections::{HashMap, HashSet},
+    sync::{
+        atomic::{AtomicBool, Ordering::Relaxed},
+        Arc,
+    },
 };
+
 use itertools::Itertools;
+use parking_lot::RwLock;
+use pyo3::{
+    types::{PyDict, PyTuple},
+    PyAny, PyObject, PyResult, Python,
+};
+
 use nac3core::{
    codegen::{
        classes::{NDArrayType, ProxyType},
        CodeGenContext, CodeGenerator,
    },
+    inkwell::{
+        module::Linkage,
+        types::{BasicType, BasicTypeEnum},
+        values::BasicValueEnum,
+        AddressSpace,
+    },
+    nac3parser::ast::{self, StrRef},
    symbol_resolver::{StaticValue, SymbolResolver, SymbolValue, ValueEnum},
    toplevel::{
        helper::PrimDef,
@ -20,21 +36,8 @@ use nac3core::{
        typedef::{into_var_map, iter_type_vars, Type, TypeEnum, TypeVar, Unifier, VarMap},
    },
 };
-use nac3parser::ast::{self, StrRef};
-use parking_lot::{Mutex, RwLock};
-use pyo3::{
-    types::{PyDict, PyTuple},
-    PyAny, PyObject, PyResult, Python,
-};
-use std::{
-    collections::{HashMap, HashSet},
-    sync::{
-        atomic::{AtomicBool, Ordering::Relaxed},
-        Arc,
-    },
-};

-use crate::PrimitivePythonId;
+use super::PrimitivePythonId;

 pub enum PrimitiveValue {
    I32(i32),
@ -79,7 +82,6 @@ pub struct InnerResolver {
    pub id_to_primitive: RwLock<HashMap<u64, PrimitiveValue>>,
    pub field_to_val: RwLock<HashMap<ResolverField, Option<PyFieldHandle>>>,
    pub global_value_ids: Arc<RwLock<HashMap<u64, PyObject>>>,
-    pub class_names: Mutex<HashMap<StrRef, Type>>,
    pub pyid_to_def: Arc<RwLock<HashMap<u64, DefinitionId>>>,
    pub pyid_to_type: Arc<RwLock<HashMap<u64, Type>>>,
    pub primitive_ids: PrimitivePythonId,
@ -133,6 +135,8 @@ impl StaticValue for PythonValue {
                        format!("{}_const", self.id).as_str(),
                    );
                    global.set_constant(true);
+                    // Set linkage of global to private to avoid name collisions
+                    global.set_linkage(Linkage::Private);
                    global.set_initializer(&ctx.ctx.const_struct(
                        &[ctx.ctx.i32_type().const_int(u64::from(id), false).into()],
                        false,
@ -163,7 +167,7 @@ impl StaticValue for PythonValue {
                PrimitiveValue::Bool(val) => {
                    ctx.ctx.i8_type().const_int(u64::from(*val), false).into()
                }
-                PrimitiveValue::Str(val) => ctx.ctx.const_string(val.as_bytes(), true).into(),
+                PrimitiveValue::Str(val) => ctx.gen_string(generator, val).into(),
            });
        }
        if let Some(global) = ctx.module.get_global(&self.id.to_string()) {
@ -351,7 +355,7 @@ impl InnerResolver {
            Ok(Ok((ndarray, false)))
        } else if ty_id == self.primitive_ids.tuple {
            // do not handle type var param and concrete check here
-            Ok(Ok((unifier.add_ty(TypeEnum::TTuple { ty: vec![] }), false)))
+            Ok(Ok((unifier.add_ty(TypeEnum::TTuple { ty: vec![], is_vararg_ctx: false }), false)))
        } else if ty_id == self.primitive_ids.option {
            Ok(Ok((primitives.option, false)))
        } else if ty_id == self.primitive_ids.none {
@ -555,7 +559,10 @@ impl InnerResolver {
                            Err(err) => return Ok(Err(err)),
                            _ => return Ok(Err("tuple type needs at least 1 type parameters".to_string()))
                        };
-                    Ok(Ok((unifier.add_ty(TypeEnum::TTuple { ty: args }), true)))
+                    Ok(Ok((
+                        unifier.add_ty(TypeEnum::TTuple { ty: args, is_vararg_ctx: false }),
+                        true,
+                    )))
                }
                TypeEnum::TObj { params, obj_id, .. } => {
                    let subst = {
@ -797,7 +804,9 @@ impl InnerResolver {
                    .map(|elem| self.get_obj_type(py, elem, unifier, defs, primitives))
                    .collect();
                let types = types?;
-                Ok(types.map(|types| unifier.add_ty(TypeEnum::TTuple { ty: types })))
+                Ok(types.map(|types| {
+                    unifier.add_ty(TypeEnum::TTuple { ty: types, is_vararg_ctx: false })
+                }))
            }
            // special handling for option type since its class member layout in python side
            // is special and cannot be mapped directly to a nac3 type as below
@ -972,7 +981,7 @@ impl InnerResolver {
        } else if ty_id == self.primitive_ids.string || ty_id == self.primitive_ids.np_str_ {
            let val: String = obj.extract().unwrap();
            self.id_to_primitive.write().insert(id, PrimitiveValue::Str(val.clone()));
-            Ok(Some(ctx.ctx.const_string(val.as_bytes(), true).into()))
+            Ok(Some(ctx.gen_string(generator, val).into()))
        } else if ty_id == self.primitive_ids.float || ty_id == self.primitive_ids.float64 {
            let val: f64 = obj.extract().unwrap();
            self.id_to_primitive.write().insert(id, PrimitiveValue::F64(val));
@ -991,8 +1000,15 @@ impl InnerResolver {
                }
                _ => unreachable!("must be list"),
            };
-            let ty = ctx.get_llvm_type(generator, elem_ty);
            let size_t = generator.get_size_type(ctx.ctx);
+            let ty = if len == 0
+                && matches!(&*ctx.unifier.get_ty_immutable(elem_ty), TypeEnum::TVar { .. })
+            {
+                // The default type for zero-length lists of unknown element type is size_t
+                size_t.into()
+            } else {
+                ctx.get_llvm_type(generator, elem_ty)
+            };
            let arr_ty = ctx
                .ctx
                .struct_type(&[ty.ptr_type(AddressSpace::default()).into(), size_t.into()], false);
@ -1196,7 +1212,9 @@ impl InnerResolver {
            Ok(Some(ndarray.as_pointer_value().into()))
        } else if ty_id == self.primitive_ids.tuple {
            let expected_ty_enum = ctx.unifier.get_ty_immutable(expected_ty);
-            let TypeEnum::TTuple { ty } = expected_ty_enum.as_ref() else { unreachable!() };
+            let TypeEnum::TTuple { ty, is_vararg_ctx: false } = expected_ty_enum.as_ref() else {
+                unreachable!()
+            };

            let tup_tys = ty.iter();
            let elements: &PyTuple = obj.downcast()?;
@ -1452,6 +1470,7 @@ impl SymbolResolver for Resolver {
        &self,
        id: StrRef,
        _: &mut CodeGenContext<'ctx, '_>,
+        _: &mut dyn CodeGenerator,
    ) -> Option<ValueEnum<'ctx>> {
        let sym_value = {
            let id_to_val = self.0.id_to_pyval.read();
--- a/nac3artiq/src/timeline.rs
+++ b/nac3artiq/src/timeline.rs
@ -1,9 +1,12 @@
-use inkwell::{
+use itertools::Either;
+
+use nac3core::{
+    codegen::CodeGenContext,
+    inkwell::{
        values::{BasicValueEnum, CallSiteValue},
        AddressSpace, AtomicOrdering,
+    },
 };
-use itertools::Either;
-use nac3core::codegen::CodeGenContext;

 /// Functions for manipulating the timeline.
 pub trait TimeFns {
@ -31,7 +34,7 @@ impl TimeFns for NowPinningTimeFns64 {
            .unwrap_or_else(|| ctx.module.add_global(i64_type, None, "now"));
        let now_hiptr = ctx
            .builder
-            .build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
+            .build_bit_cast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap();

@ -80,7 +83,7 @@ impl TimeFns for NowPinningTimeFns64 {
            .unwrap_or_else(|| ctx.module.add_global(i64_type, None, "now"));
        let now_hiptr = ctx
            .builder
-            .build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
+            .build_bit_cast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap();

@ -109,7 +112,7 @@ impl TimeFns for NowPinningTimeFns64 {
            .unwrap_or_else(|| ctx.module.add_global(i64_type, None, "now"));
        let now_hiptr = ctx
            .builder
-            .build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
+            .build_bit_cast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap();

@ -207,7 +210,7 @@ impl TimeFns for NowPinningTimeFns {
            .unwrap_or_else(|| ctx.module.add_global(i64_type, None, "now"));
        let now_hiptr = ctx
            .builder
-            .build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
+            .build_bit_cast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap();

@ -258,7 +261,7 @@ impl TimeFns for NowPinningTimeFns {
        let time_lo = ctx.builder.build_int_truncate(time, i32_type, "time.lo").unwrap();
        let now_hiptr = ctx
            .builder
-            .build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
+            .build_bit_cast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap();

--- a/nac3ast/Cargo.toml
+++ b/nac3ast/Cargo.toml
@ -10,7 +10,6 @@ constant-optimization = ["fold"]
 fold = []

 [dependencies]
-lazy_static = "1.5"
 parking_lot = "0.12"
 string-interner = "0.17"
 fxhash = "0.2"
--- a/nac3ast/src/ast_gen.rs
+++ b/nac3ast/src/ast_gen.rs
@ -5,14 +5,12 @@ pub use crate::location::Location;

 use fxhash::FxBuildHasher;
 use parking_lot::{Mutex, MutexGuard};
-use std::{cell::RefCell, collections::HashMap, fmt};
+use std::{cell::RefCell, collections::HashMap, fmt, sync::LazyLock};
 use string_interner::{symbol::SymbolU32, DefaultBackend, StringInterner};

 pub type Interner = StringInterner<DefaultBackend, FxBuildHasher>;
-lazy_static! {
-    static ref INTERNER: Mutex<Interner> =
-        Mutex::new(StringInterner::with_hasher(FxBuildHasher::default()));
-}
+static INTERNER: LazyLock<Mutex<Interner>> =
+    LazyLock::new(|| Mutex::new(StringInterner::with_hasher(FxBuildHasher::default())));

 thread_local! {
    static LOCAL_INTERNER: RefCell<HashMap<String, StrRef>> = RefCell::default();
--- a/nac3ast/src/lib.rs
+++ b/nac3ast/src/lib.rs
@ -14,9 +14,6 @@
    clippy::wildcard_imports
 )]

-#[macro_use]
-extern crate lazy_static;
-
 mod ast_gen;
 mod constant;
 #[cfg(feature = "fold")]
--- a/nac3core/Cargo.toml
+++ b/nac3core/Cargo.toml
@ -1,26 +1,26 @@
-[features]
-test = []
-
 [package]
 name = "nac3core"
 version = "0.1.0"
 authors = ["M-Labs"]
 edition = "2021"

+[features]
+no-escape-analysis = []
+
 [dependencies]
 itertools = "0.13"
 crossbeam = "0.8"
-indexmap = "2.2"
+indexmap = "2.6"
 parking_lot = "0.12"
-rayon = "1.8"
+rayon = "1.10"
 nac3parser = { path = "../nac3parser" }
-strum = "0.26.2"
-strum_macros = "0.26.4"
+strum = "0.26"
+strum_macros = "0.26"

 [dependencies.inkwell]
-version = "0.4"
+version = "0.5"
 default-features = false
-features = ["llvm14-0", "target-x86", "target-arm", "target-riscv", "no-libffi-linking"]
+features = ["llvm14-0-prefer-dynamic", "target-x86", "target-arm", "target-riscv", "no-libffi-linking"]

 [dev-dependencies]
 test-case = "1.2.0"
--- a/nac3core/build.rs
+++ b/nac3core/build.rs
@ -1,4 +1,3 @@
-use regex::Regex;
 use std::{
    env,
    fs::File,
@ -7,39 +6,53 @@ use std::{
    process::{Command, Stdio},
 };

-fn compile_irrt(irrt_dir: &Path, out_dir: &Path) {
+use regex::Regex;
+
+fn main() {
+    let out_dir = env::var("OUT_DIR").unwrap();
+    let out_dir = Path::new(&out_dir);
+    let irrt_dir = Path::new("irrt");
+
    let irrt_cpp_path = irrt_dir.join("irrt.cpp");

    /*
     * HACK: Sadly, clang doesn't let us emit generic LLVM bitcode.
     * Compiling for WASM32 and filtering the output with regex is the closest we can get.
     */
-    let flags: &[&str] = &[
+    let mut flags: Vec<&str> = vec![
        "--target=wasm32",
-        irrt_cpp_path.to_str().unwrap(),
        "-x",
        "c++",
+        "-std=c++20",
        "-fno-discard-value-names",
        "-fno-exceptions",
        "-fno-rtti",
-        match env::var("PROFILE").as_deref() {
-            Ok("debug") => "-O0",
-            Ok("release") => "-O3",
-            flavor => panic!("Unknown or missing build flavor {flavor:?}"),
-        },
        "-emit-llvm",
        "-S",
        "-Wall",
        "-Wextra",
-        "-Werror=return-type",
-        "-I",
-        irrt_dir.to_str().unwrap(),
        "-o",
        "-",
+        "-I",
+        irrt_dir.to_str().unwrap(),
+        irrt_cpp_path.to_str().unwrap(),
    ];

-    println!("cargo:rerun-if-changed={}", out_dir.to_str().unwrap());
+    match env::var("PROFILE").as_deref() {
+        Ok("debug") => {
+            flags.push("-O0");
+            flags.push("-DIRRT_DEBUG_ASSERT");
+        }
+        Ok("release") => {
+            flags.push("-O3");
+        }
+        flavor => panic!("Unknown or missing build flavor {flavor:?}"),
+    }

+    // Tell Cargo to rerun if any file under `irrt_dir` (recursive) changes
+    println!("cargo:rerun-if-changed={}", irrt_dir.to_str().unwrap());
+
+    // Compile IRRT and capture the LLVM IR output
    let output = Command::new("clang-irrt")
        .args(flags)
        .output()
@ -53,11 +66,17 @@ fn compile_irrt(irrt_dir: &Path, out_dir: &Path) {
    let output = std::str::from_utf8(&output.stdout).unwrap().replace("\r\n", "\n");
    let mut filtered_output = String::with_capacity(output.len());

-    // (?ms:^define.*?\}$) to capture `define` blocks
-    // (?m:^declare.*?$) to capture `declare` blocks
-    // (?m:^%.+?=\s*type\s*\{.+?\}$) to capture `type` declarations
-    let regex_filter =
-        Regex::new(r"(?ms:^define.*?\}$)|(?m:^declare.*?$)|(?m:^%.+?=\s*type\s*\{.+?\}$)").unwrap();
+    // Filter out irrelevant IR
+    //
+    // Regex:
+    // - `(?ms:^define.*?\}$)` captures LLVM `define` blocks
+    // - `(?m:^declare.*?$)` captures LLVM `declare` lines
+    // - `(?m:^%.+?=\s*type\s*\{.+?\}$)` captures LLVM `type` declarations
+    // - `(?m:^@.+?=.+$)` captures global constants
+    let regex_filter = Regex::new(
+        r"(?ms:^define.*?\}$)|(?m:^declare.*?$)|(?m:^%.+?=\s*type\s*\{.+?\}$)|(?m:^@.+?=.+$)",
+    )
+    .unwrap();
    for f in regex_filter.captures_iter(&output) {
        assert_eq!(f.len(), 1);
        filtered_output.push_str(&f[0]);
@ -68,10 +87,14 @@ fn compile_irrt(irrt_dir: &Path, out_dir: &Path) {
        .unwrap()
        .replace_all(&filtered_output, "");

-    println!("cargo:rerun-if-env-changed=DEBUG_DUMP_IRRT");
-    if env::var("DEBUG_DUMP_IRRT").is_ok() {
+    // For debugging
+    // Doing `DEBUG_DUMP_IRRT=1 cargo build -p nac3core` dumps the LLVM IR generated
+    const DEBUG_DUMP_IRRT: &str = "DEBUG_DUMP_IRRT";
+    println!("cargo:rerun-if-env-changed={DEBUG_DUMP_IRRT}");
+    if env::var(DEBUG_DUMP_IRRT).is_ok() {
        let mut file = File::create(out_dir.join("irrt.ll")).unwrap();
        file.write_all(output.as_bytes()).unwrap();
+
        let mut file = File::create(out_dir.join("irrt-filtered.ll")).unwrap();
        file.write_all(filtered_output.as_bytes()).unwrap();
    }
@ -85,50 +108,3 @@ fn compile_irrt(irrt_dir: &Path, out_dir: &Path) {
    llvm_as.stdin.as_mut().unwrap().write_all(filtered_output.as_bytes()).unwrap();
    assert!(llvm_as.wait().unwrap().success());
 }
-
-fn compile_irrt_test(irrt_dir: &Path, out_dir: &Path) {
-    let irrt_test_cpp_path = irrt_dir.join("irrt_test.cpp");
-    let exe_path = out_dir.join("irrt_test.out");
-
-    let flags: &[&str] = &[
-        irrt_test_cpp_path.to_str().unwrap(),
-        "-x",
-        "c++",
-        "-I",
-        irrt_dir.to_str().unwrap(),
-        "-g",
-        "-fno-discard-value-names",
-        "-O0",
-        "-Wall",
-        "-Wextra",
-        "-Werror=return-type",
-        "-lm", // for `tgamma()`, `lgamma()`
-        "-o",
-        exe_path.to_str().unwrap(),
-    ];
-
-    Command::new("clang-irrt-test")
-        .args(flags)
-        .output()
-        .map(|o| {
-            assert!(o.status.success(), "{}", std::str::from_utf8(&o.stderr).unwrap());
-            o
-        })
-        .unwrap();
-    println!("cargo:rerun-if-changed={}", out_dir.to_str().unwrap());
-}
-
-fn main() {
-    let out_dir = env::var("OUT_DIR").unwrap();
-    let out_dir = Path::new(&out_dir);
-
-    let irrt_dir = Path::new("./irrt");
-
-    compile_irrt(irrt_dir, out_dir);
-
-    // https://github.com/rust-lang/cargo/issues/2549
-    // `cargo test -F test` to also build `irrt_test.cpp
-    if cfg!(feature = "test") {
-        compile_irrt_test(irrt_dir, out_dir);
-    }
-}
--- a/nac3core/irrt/irrt.cpp
+++ b/nac3core/irrt/irrt.cpp
@ -1,5 +1,6 @@
-#include "irrt_everything.hpp"
-
-/*
-    This file will be read by `clang-irrt` to conveniently produce LLVM IR for `nac3core/codegen`.
-*/
+#include "irrt/exception.hpp"
+#include "irrt/int_types.hpp"
+#include "irrt/list.hpp"
+#include "irrt/math.hpp"
+#include "irrt/ndarray.hpp"
+#include "irrt/slice.hpp"
--- a/nac3core/irrt/irrt.hpp
+++ b/nac3core/irrt/irrt.hpp
@ -1,437 +0,0 @@
-#ifndef IRRT_DONT_TYPEDEF_INTS
-typedef _BitInt(8) int8_t;
-typedef unsigned _BitInt(8) uint8_t;
-typedef _BitInt(32) int32_t;
-typedef unsigned _BitInt(32) uint32_t;
-typedef _BitInt(64) int64_t;
-typedef unsigned _BitInt(64) uint64_t;
-#endif
-
-// NDArray indices are always `uint32_t`.
-typedef uint32_t NDIndex;
-// The type of an index or a value describing the length of a range/slice is
-// always `int32_t`.
-typedef int32_t SliceIndex;
-
-template <typename T>
-static T max(T a, T b) {
-    return a > b ? a : b;
-}
-
-template <typename T>
-static T min(T a, T b) {
-    return a > b ? b : a;
-}
-
-// adapted from GNU Scientific Library: https://git.savannah.gnu.org/cgit/gsl.git/tree/sys/pow_int.c
-// need to make sure `exp >= 0` before calling this function
-template <typename T>
-static T __nac3_int_exp_impl(T base, T exp) {
-    T res = 1;
-    /* repeated squaring method */
-    do {
-        if (exp & 1) {
-            res *= base; /* for n odd */
-        }
-        exp >>= 1;
-        base *= base;
-    } while (exp);
-    return res;
-}
-
-template <typename SizeT>
-static SizeT __nac3_ndarray_calc_size_impl(
-    const SizeT *list_data,
-    SizeT list_len,
-    SizeT begin_idx,
-    SizeT end_idx
-) {
-    __builtin_assume(end_idx <= list_len);
-
-    SizeT num_elems = 1;
-    for (SizeT i = begin_idx; i < end_idx; ++i) {
-        SizeT val = list_data[i];
-        __builtin_assume(val > 0);
-        num_elems *= val;
-    }
-    return num_elems;
-}
-
-template <typename SizeT>
-static void __nac3_ndarray_calc_nd_indices_impl(
-    SizeT index,
-    const SizeT *dims,
-    SizeT num_dims,
-    NDIndex *idxs
-) {
-    SizeT stride = 1;
-    for (SizeT dim = 0; dim < num_dims; dim++) {
-        SizeT i = num_dims - dim - 1;
-        __builtin_assume(dims[i] > 0);
-        idxs[i] = (index / stride) % dims[i];
-        stride *= dims[i];
-    }
-}
-
-template <typename SizeT>
-static SizeT __nac3_ndarray_flatten_index_impl(
-    const SizeT *dims,
-    SizeT num_dims,
-    const NDIndex *indices,
-    SizeT num_indices
-) {
-    SizeT idx = 0;
-    SizeT stride = 1;
-    for (SizeT i = 0; i < num_dims; ++i) {
-        SizeT ri = num_dims - i - 1;
-        if (ri < num_indices) {
-            idx += stride * indices[ri];
-        }
-
-        __builtin_assume(dims[i] > 0);
-        stride *= dims[ri];
-    }
-    return idx;
-}
-
-template <typename SizeT>
-static void __nac3_ndarray_calc_broadcast_impl(
-    const SizeT *lhs_dims,
-    SizeT lhs_ndims,
-    const SizeT *rhs_dims,
-    SizeT rhs_ndims,
-    SizeT *out_dims
-) {
-    SizeT max_ndims = lhs_ndims > rhs_ndims ? lhs_ndims : rhs_ndims;
-
-    for (SizeT i = 0; i < max_ndims; ++i) {
-        const SizeT *lhs_dim_sz = i < lhs_ndims ? &lhs_dims[lhs_ndims - i - 1] : nullptr;
-        const SizeT *rhs_dim_sz = i < rhs_ndims ? &rhs_dims[rhs_ndims - i - 1] : nullptr;
-        SizeT *out_dim = &out_dims[max_ndims - i - 1];
-
-        if (lhs_dim_sz == nullptr) {
-            *out_dim = *rhs_dim_sz;
-        } else if (rhs_dim_sz == nullptr) {
-            *out_dim = *lhs_dim_sz;
-        } else if (*lhs_dim_sz == 1) {
-            *out_dim = *rhs_dim_sz;
-        } else if (*rhs_dim_sz == 1) {
-            *out_dim = *lhs_dim_sz;
-        } else if (*lhs_dim_sz == *rhs_dim_sz) {
-            *out_dim = *lhs_dim_sz;
-        } else {
-            __builtin_unreachable();
-        }
-    }
-}
-
-template <typename SizeT>
-static void __nac3_ndarray_calc_broadcast_idx_impl(
-    const SizeT *src_dims,
-    SizeT src_ndims,
-    const NDIndex *in_idx,
-    NDIndex *out_idx
-) {
-    for (SizeT i = 0; i < src_ndims; ++i) {
-        SizeT src_i = src_ndims - i - 1;
-        out_idx[src_i] = src_dims[src_i] == 1 ? 0 : in_idx[src_i];
-    }
-}
-
-template<typename SizeT>
-static void __nac3_ndarray_strides_from_shape_impl(
-    SizeT ndims,
-    SizeT *shape,
-    SizeT *dst_strides
-) {
-    SizeT stride_product = 1;
-    for (SizeT i = 0; i < ndims; i++) {
-        int dim_i = ndims - i - 1;
-        dst_strides[dim_i] = stride_product;
-        stride_product *= shape[dim_i];
-    }
-}
-
-extern "C" {
-    #define DEF_nac3_int_exp_(T) \
-        T __nac3_int_exp_##T(T base, T exp) {\
-            return __nac3_int_exp_impl(base, exp);\
-        }
-
-    DEF_nac3_int_exp_(int32_t)
-    DEF_nac3_int_exp_(int64_t)
-    DEF_nac3_int_exp_(uint32_t)
-    DEF_nac3_int_exp_(uint64_t)
-
-    SliceIndex __nac3_slice_index_bound(SliceIndex i, const SliceIndex len) {
-        if (i < 0) {
-            i = len + i;
-        }
-        if (i < 0) {
-            return 0;
-        } else if (i > len) {
-            return len;
-        }
-        return i;
-    }
-
-    SliceIndex __nac3_range_slice_len(
-        const SliceIndex start,
-        const SliceIndex end,
-        const SliceIndex step
-    ) {
-        SliceIndex diff = end - start;
-        if (diff > 0 && step > 0) {
-            return ((diff - 1) / step) + 1;
-        } else if (diff < 0 && step < 0) {
-            return ((diff + 1) / step) + 1;
-        } else {
-            return 0;
-        }
-    }
-
-    // Handle list assignment and dropping part of the list when
-    // both dest_step and src_step are +1.
-    // - All the index must *not* be out-of-bound or negative,
-    // - The end index is *inclusive*,
-    // - The length of src and dest slice size should already
-    // be checked: if dest.step == 1 then len(src) <= len(dest) else len(src) == len(dest)
-    SliceIndex __nac3_list_slice_assign_var_size(
-        SliceIndex dest_start,
-        SliceIndex dest_end,
-        SliceIndex dest_step,
-        uint8_t *dest_arr,
-        SliceIndex dest_arr_len,
-        SliceIndex src_start,
-        SliceIndex src_end,
-        SliceIndex src_step,
-        uint8_t *src_arr,
-        SliceIndex src_arr_len,
-        const SliceIndex size
-    ) {
-        /* if dest_arr_len == 0, do nothing since we do not support extending list */
-        if (dest_arr_len == 0) return dest_arr_len;
-        /* if both step is 1, memmove directly, handle the dropping of the list, and shrink size */
-        if (src_step == dest_step && dest_step == 1) {
-            const SliceIndex src_len = (src_end >= src_start) ? (src_end - src_start + 1) : 0;
-            const SliceIndex dest_len = (dest_end >= dest_start) ? (dest_end - dest_start + 1) : 0;
-            if (src_len > 0) {
-                __builtin_memmove(
-                    dest_arr + dest_start * size,
-                    src_arr + src_start * size,
-                    src_len * size
-                );
-            }
-            if (dest_len > 0) {
-                /* dropping */
-                __builtin_memmove(
-                    dest_arr + (dest_start + src_len) * size,
-                    dest_arr + (dest_end + 1) * size,
-                    (dest_arr_len - dest_end - 1) * size
-                );
-            }
-            /* shrink size */
-            return dest_arr_len - (dest_len - src_len);
-        }
-        /* if two range overlaps, need alloca */
-        uint8_t need_alloca =
-            (dest_arr == src_arr)
-            && !(
-                max(dest_start, dest_end) < min(src_start, src_end)
-                || max(src_start, src_end) < min(dest_start, dest_end)
-            );
-        if (need_alloca) {
-            uint8_t *tmp = reinterpret_cast<uint8_t *>(__builtin_alloca(src_arr_len * size));
-            __builtin_memcpy(tmp, src_arr, src_arr_len * size);
-            src_arr = tmp;
-        }
-        SliceIndex src_ind = src_start;
-        SliceIndex dest_ind = dest_start;
-        for (;
-            (src_step > 0) ? (src_ind <= src_end) : (src_ind >= src_end);
-            src_ind += src_step, dest_ind += dest_step
-        ) {
-            /* for constant optimization */
-            if (size == 1) {
-                __builtin_memcpy(dest_arr + dest_ind, src_arr + src_ind, 1);
-            } else if (size == 4) {
-                __builtin_memcpy(dest_arr + dest_ind * 4, src_arr + src_ind * 4, 4);
-            } else if (size == 8) {
-                __builtin_memcpy(dest_arr + dest_ind * 8, src_arr + src_ind * 8, 8);
-            } else {
-                /* memcpy for var size, cannot overlap after previous alloca */
-                __builtin_memcpy(dest_arr + dest_ind * size, src_arr + src_ind * size, size);
-            }
-        }
-        /* only dest_step == 1 can we shrink the dest list. */
-        /* size should be ensured prior to calling this function */
-        if (dest_step == 1 && dest_end >= dest_start) {
-            __builtin_memmove(
-                dest_arr + dest_ind * size,
-                dest_arr + (dest_end + 1) * size,
-                (dest_arr_len - dest_end - 1) * size
-            );
-            return dest_arr_len - (dest_end - dest_ind) - 1;
-        }
-        return dest_arr_len;
-    }
-
-    int32_t __nac3_isinf(double x) {
-        return __builtin_isinf(x);
-    }
-
-    int32_t __nac3_isnan(double x) {
-        return __builtin_isnan(x);
-    }
-
-    double tgamma(double arg);
-
-    double __nac3_gamma(double z) {
-        // Handling for denormals
-        //     | x                 | Python gamma(x) | C tgamma(x) |
-        // --- | ----------------- | --------------- | ----------- |
-        // (1) | nan               | nan             | nan         |
-        // (2) | -inf              | -inf            | inf         |
-        // (3) | inf               | inf             | inf         |
-        // (4) | 0.0               | inf             | inf         |
-        // (5) | {-1.0, -2.0, ...} | inf             | nan         |
-
-        // (1)-(3)
-        if (__builtin_isinf(z) || __builtin_isnan(z)) {
-            return z;
-        }
-
-        double v = tgamma(z);
-
-        // (4)-(5)
-        return __builtin_isinf(v) || __builtin_isnan(v) ? __builtin_inf() : v;
-    }
-
-    double lgamma(double arg);
-
-    double __nac3_gammaln(double x) {
-        // libm's handling of value overflows differs from scipy:
-        // - scipy: gammaln(-inf) -> -inf
-        // - libm : lgamma(-inf) -> inf
-
-        if (__builtin_isinf(x)) {
-            return x;
-        }
-
-        return lgamma(x);
-    }
-
-    double j0(double x);
-
-    double __nac3_j0(double x) {
-        // libm's handling of value overflows differs from scipy:
-        // - scipy: j0(inf) -> nan
-        // - libm : j0(inf) -> 0.0
-
-        if (__builtin_isinf(x)) {
-            return __builtin_nan("");
-        }
-
-        return j0(x);
-    }
-
-    uint32_t __nac3_ndarray_calc_size(
-        const uint32_t *list_data,
-        uint32_t list_len,
-        uint32_t begin_idx,
-        uint32_t end_idx
-    ) {
-        return __nac3_ndarray_calc_size_impl(list_data, list_len, begin_idx, end_idx);
-    }
-
-    uint64_t __nac3_ndarray_calc_size64(
-        const uint64_t *list_data,
-        uint64_t list_len,
-        uint64_t begin_idx,
-        uint64_t end_idx
-    ) {
-        return __nac3_ndarray_calc_size_impl(list_data, list_len, begin_idx, end_idx);
-    }
-
-    void __nac3_ndarray_calc_nd_indices(
-        uint32_t index,
-        const uint32_t* dims,
-        uint32_t num_dims,
-        NDIndex* idxs
-    ) {
-        __nac3_ndarray_calc_nd_indices_impl(index, dims, num_dims, idxs);
-    }
-
-    void __nac3_ndarray_calc_nd_indices64(
-        uint64_t index,
-        const uint64_t* dims,
-        uint64_t num_dims,
-        NDIndex* idxs
-    ) {
-        __nac3_ndarray_calc_nd_indices_impl(index, dims, num_dims, idxs);
-    }
-
-    uint32_t __nac3_ndarray_flatten_index(
-        const uint32_t* dims,
-        uint32_t num_dims,
-        const NDIndex* indices,
-        uint32_t num_indices
-    ) {
-        return __nac3_ndarray_flatten_index_impl(dims, num_dims, indices, num_indices);
-    }
-
-    uint64_t __nac3_ndarray_flatten_index64(
-        const uint64_t* dims,
-        uint64_t num_dims,
-        const NDIndex* indices,
-        uint64_t num_indices
-    ) {
-        return __nac3_ndarray_flatten_index_impl(dims, num_dims, indices, num_indices);
-    }
-
-    void __nac3_ndarray_calc_broadcast(
-        const uint32_t *lhs_dims,
-        uint32_t lhs_ndims,
-        const uint32_t *rhs_dims,
-        uint32_t rhs_ndims,
-        uint32_t *out_dims
-    ) {
-        return __nac3_ndarray_calc_broadcast_impl(lhs_dims, lhs_ndims, rhs_dims, rhs_ndims, out_dims);
-    }
-
-    void __nac3_ndarray_calc_broadcast64(
-        const uint64_t *lhs_dims,
-        uint64_t lhs_ndims,
-        const uint64_t *rhs_dims,
-        uint64_t rhs_ndims,
-        uint64_t *out_dims
-    ) {
-        return __nac3_ndarray_calc_broadcast_impl(lhs_dims, lhs_ndims, rhs_dims, rhs_ndims, out_dims);
-    }
-
-    void __nac3_ndarray_calc_broadcast_idx(
-        const uint32_t *src_dims,
-        uint32_t src_ndims,
-        const NDIndex *in_idx,
-        NDIndex *out_idx
-    ) {
-        __nac3_ndarray_calc_broadcast_idx_impl(src_dims, src_ndims, in_idx, out_idx);
-    }
-
-    void __nac3_ndarray_calc_broadcast_idx64(
-        const uint64_t *src_dims,
-        uint64_t src_ndims,
-        const NDIndex *in_idx,
-        NDIndex *out_idx
-    ) {
-        __nac3_ndarray_calc_broadcast_idx_impl(src_dims, src_ndims, in_idx, out_idx);
-    }
-
-    void __nac3_ndarray_strides_from_shape(uint32_t ndims, uint32_t* shape, uint32_t* dst_strides) {
-        __nac3_ndarray_strides_from_shape_impl(ndims, shape, dst_strides);
-    }
-
-    void __nac3_ndarray_strides_from_shape64(uint64_t ndims, uint64_t* shape, uint64_t* dst_strides) {
-        __nac3_ndarray_strides_from_shape_impl(ndims, shape, dst_strides);
-    }
-}
--- a/nac3core/irrt/irrt/cslice.hpp
+++ b/nac3core/irrt/irrt/cslice.hpp
@ -0,0 +1,9 @@
+#pragma once
+
+#include "irrt/int_types.hpp"
+
+template<typename SizeT>
+struct CSlice {
+    uint8_t* base;
+    SizeT len;
+};
--- a/nac3core/irrt/irrt/debug.hpp
+++ b/nac3core/irrt/irrt/debug.hpp
@ -0,0 +1,25 @@
+#pragma once
+
+// Set in nac3core/build.rs
+#ifdef IRRT_DEBUG_ASSERT
+#define IRRT_DEBUG_ASSERT_BOOL true
+#else
+#define IRRT_DEBUG_ASSERT_BOOL false
+#endif
+
+#define raise_debug_assert(SizeT, msg, param1, param2, param3) \
+    raise_exception(SizeT, EXN_ASSERTION_ERROR, "IRRT debug assert failed: " msg, param1, param2, param3)
+
+#define debug_assert_eq(SizeT, lhs, rhs)                                           \
+    if constexpr (IRRT_DEBUG_ASSERT_BOOL) {                                        \
+        if ((lhs) != (rhs)) {                                                      \
+            raise_debug_assert(SizeT, "LHS = {0}. RHS = {1}", lhs, rhs, NO_PARAM); \
+        }                                                                          \
+    }
+
+#define debug_assert(SizeT, expr)                                                  \
+    if constexpr (IRRT_DEBUG_ASSERT_BOOL) {                                        \
+        if (!(expr)) {                                                             \
+            raise_debug_assert(SizeT, "Got false.", NO_PARAM, NO_PARAM, NO_PARAM); \
+        }                                                                          \
+    }
--- a/nac3core/irrt/irrt/exception.hpp
+++ b/nac3core/irrt/irrt/exception.hpp
@ -0,0 +1,82 @@
+#pragma once
+
+#include "irrt/cslice.hpp"
+#include "irrt/int_types.hpp"
+
+/**
+ * @brief The int type of ARTIQ exception IDs.
+ */
+typedef int32_t ExceptionId;
+
+/*
+ * Set of exceptions C++ IRRT can use.
+ * Must be synchronized with `setup_irrt_exceptions` in `nac3core/src/codegen/irrt/mod.rs`.
+ */
+extern "C" {
+ExceptionId EXN_INDEX_ERROR;
+ExceptionId EXN_VALUE_ERROR;
+ExceptionId EXN_ASSERTION_ERROR;
+ExceptionId EXN_TYPE_ERROR;
+}
+
+/**
+ * @brief Extern function to `__nac3_raise`
+ *
+ * The parameter `err` could be `Exception<int32_t>` or `Exception<int64_t>`. The caller
+ * must make sure to pass `Exception`s with the correct `SizeT` depending on the `size_t` of the runtime.
+ */
+extern "C" void __nac3_raise(void* err);
+
+namespace {
+/**
+ * @brief NAC3's Exception struct
+ */
+template<typename SizeT>
+struct Exception {
+    ExceptionId id;
+    CSlice<SizeT> filename;
+    int32_t line;
+    int32_t column;
+    CSlice<SizeT> function;
+    CSlice<SizeT> msg;
+    int64_t params[3];
+};
+
+constexpr int64_t NO_PARAM = 0;
+
+template<typename SizeT>
+void _raise_exception_helper(ExceptionId id,
+                             const char* filename,
+                             int32_t line,
+                             const char* function,
+                             const char* msg,
+                             int64_t param0,
+                             int64_t param1,
+                             int64_t param2) {
+    Exception<SizeT> e = {
+        .id = id,
+        .filename = {.base = reinterpret_cast<const uint8_t*>(filename), .len = __builtin_strlen(filename)},
+        .line = line,
+        .column = 0,
+        .function = {.base = reinterpret_cast<const uint8_t*>(function), .len = __builtin_strlen(function)},
+        .msg = {.base = reinterpret_cast<const uint8_t*>(msg), .len = __builtin_strlen(msg)},
+    };
+    e.params[0] = param0;
+    e.params[1] = param1;
+    e.params[2] = param2;
+    __nac3_raise(reinterpret_cast<void*>(&e));
+    __builtin_unreachable();
+}
+
+/**
+ * @brief Raise an exception with location details (location in the IRRT source files).
+ * @param SizeT The runtime `size_t` type.
+ * @param id The ID of the exception to raise.
+ * @param msg A global constant C-string of the error message.
+ *
+ * `param0` to `param2` are optional format arguments of `msg`. They should be set to
+ * `NO_PARAM` to indicate they are unused.
+ */
+#define raise_exception(SizeT, id, msg, param0, param1, param2) \
+    _raise_exception_helper<SizeT>(id, __FILE__, __LINE__, __FUNCTION__, msg, param0, param1, param2)
+}  // namespace
--- a/nac3core/irrt/irrt/int_types.hpp
+++ b/nac3core/irrt/irrt/int_types.hpp
@ -0,0 +1,22 @@
+#pragma once
+
+#if __STDC_VERSION__ >= 202000
+using int8_t = _BitInt(8);
+using uint8_t = unsigned _BitInt(8);
+using int32_t = _BitInt(32);
+using uint32_t = unsigned _BitInt(32);
+using int64_t = _BitInt(64);
+using uint64_t = unsigned _BitInt(64);
+#else
+using int8_t = _ExtInt(8);
+using uint8_t = unsigned _ExtInt(8);
+using int32_t = _ExtInt(32);
+using uint32_t = unsigned _ExtInt(32);
+using int64_t = _ExtInt(64);
+using uint64_t = unsigned _ExtInt(64);
+#endif
+
+// NDArray indices are always `uint32_t`.
+using NDIndex = uint32_t;
+// The type of an index or a value describing the length of a range/slice is always `int32_t`.
+using SliceIndex = int32_t;
--- a/nac3core/irrt/irrt/list.hpp
+++ b/nac3core/irrt/irrt/list.hpp
@ -0,0 +1,75 @@
+#pragma once
+
+#include "irrt/int_types.hpp"
+#include "irrt/math_util.hpp"
+
+extern "C" {
+// Handle list assignment and dropping part of the list when
+// both dest_step and src_step are +1.
+// - All the index must *not* be out-of-bound or negative,
+// - The end index is *inclusive*,
+// - The length of src and dest slice size should already
+// be checked: if dest.step == 1 then len(src) <= len(dest) else len(src) == len(dest)
+SliceIndex __nac3_list_slice_assign_var_size(SliceIndex dest_start,
+                                             SliceIndex dest_end,
+                                             SliceIndex dest_step,
+                                             uint8_t* dest_arr,
+                                             SliceIndex dest_arr_len,
+                                             SliceIndex src_start,
+                                             SliceIndex src_end,
+                                             SliceIndex src_step,
+                                             uint8_t* src_arr,
+                                             SliceIndex src_arr_len,
+                                             const SliceIndex size) {
+    /* if dest_arr_len == 0, do nothing since we do not support extending list */
+    if (dest_arr_len == 0)
+        return dest_arr_len;
+    /* if both step is 1, memmove directly, handle the dropping of the list, and shrink size */
+    if (src_step == dest_step && dest_step == 1) {
+        const SliceIndex src_len = (src_end >= src_start) ? (src_end - src_start + 1) : 0;
+        const SliceIndex dest_len = (dest_end >= dest_start) ? (dest_end - dest_start + 1) : 0;
+        if (src_len > 0) {
+            __builtin_memmove(dest_arr + dest_start * size, src_arr + src_start * size, src_len * size);
+        }
+        if (dest_len > 0) {
+            /* dropping */
+            __builtin_memmove(dest_arr + (dest_start + src_len) * size, dest_arr + (dest_end + 1) * size,
+                              (dest_arr_len - dest_end - 1) * size);
+        }
+        /* shrink size */
+        return dest_arr_len - (dest_len - src_len);
+    }
+    /* if two range overlaps, need alloca */
+    uint8_t need_alloca = (dest_arr == src_arr)
+                          && !(max(dest_start, dest_end) < min(src_start, src_end)
+                               || max(src_start, src_end) < min(dest_start, dest_end));
+    if (need_alloca) {
+        uint8_t* tmp = reinterpret_cast<uint8_t*>(__builtin_alloca(src_arr_len * size));
+        __builtin_memcpy(tmp, src_arr, src_arr_len * size);
+        src_arr = tmp;
+    }
+    SliceIndex src_ind = src_start;
+    SliceIndex dest_ind = dest_start;
+    for (; (src_step > 0) ? (src_ind <= src_end) : (src_ind >= src_end); src_ind += src_step, dest_ind += dest_step) {
+        /* for constant optimization */
+        if (size == 1) {
+            __builtin_memcpy(dest_arr + dest_ind, src_arr + src_ind, 1);
+        } else if (size == 4) {
+            __builtin_memcpy(dest_arr + dest_ind * 4, src_arr + src_ind * 4, 4);
+        } else if (size == 8) {
+            __builtin_memcpy(dest_arr + dest_ind * 8, src_arr + src_ind * 8, 8);
+        } else {
+            /* memcpy for var size, cannot overlap after previous alloca */
+            __builtin_memcpy(dest_arr + dest_ind * size, src_arr + src_ind * size, size);
+        }
+    }
+    /* only dest_step == 1 can we shrink the dest list. */
+    /* size should be ensured prior to calling this function */
+    if (dest_step == 1 && dest_end >= dest_start) {
+        __builtin_memmove(dest_arr + dest_ind * size, dest_arr + (dest_end + 1) * size,
+                          (dest_arr_len - dest_end - 1) * size);
+        return dest_arr_len - (dest_end - dest_ind) - 1;
+    }
+    return dest_arr_len;
+}
+}  // extern "C"
--- a/nac3core/irrt/irrt/math.hpp
+++ b/nac3core/irrt/irrt/math.hpp
@ -0,0 +1,93 @@
+#pragma once
+
+namespace {
+// adapted from GNU Scientific Library: https://git.savannah.gnu.org/cgit/gsl.git/tree/sys/pow_int.c
+// need to make sure `exp >= 0` before calling this function
+template<typename T>
+T __nac3_int_exp_impl(T base, T exp) {
+    T res = 1;
+    /* repeated squaring method */
+    do {
+        if (exp & 1) {
+            res *= base; /* for n odd */
+        }
+        exp >>= 1;
+        base *= base;
+    } while (exp);
+    return res;
+}
+}  // namespace
+
+#define DEF_nac3_int_exp_(T)                   \
+    T __nac3_int_exp_##T(T base, T exp) {      \
+        return __nac3_int_exp_impl(base, exp); \
+    }
+
+extern "C" {
+
+// Putting semicolons here to make clang-format not reformat this into
+// a stair shape.
+DEF_nac3_int_exp_(int32_t);
+DEF_nac3_int_exp_(int64_t);
+DEF_nac3_int_exp_(uint32_t);
+DEF_nac3_int_exp_(uint64_t);
+
+int32_t __nac3_isinf(double x) {
+    return __builtin_isinf(x);
+}
+
+int32_t __nac3_isnan(double x) {
+    return __builtin_isnan(x);
+}
+
+double tgamma(double arg);
+
+double __nac3_gamma(double z) {
+    // Handling for denormals
+    //     | x                 | Python gamma(x) | C tgamma(x) |
+    // --- | ----------------- | --------------- | ----------- |
+    // (1) | nan               | nan             | nan         |
+    // (2) | -inf              | -inf            | inf         |
+    // (3) | inf               | inf             | inf         |
+    // (4) | 0.0               | inf             | inf         |
+    // (5) | {-1.0, -2.0, ...} | inf             | nan         |
+
+    // (1)-(3)
+    if (__builtin_isinf(z) || __builtin_isnan(z)) {
+        return z;
+    }
+
+    double v = tgamma(z);
+
+    // (4)-(5)
+    return __builtin_isinf(v) || __builtin_isnan(v) ? __builtin_inf() : v;
+}
+
+double lgamma(double arg);
+
+double __nac3_gammaln(double x) {
+    // libm's handling of value overflows differs from scipy:
+    // - scipy: gammaln(-inf) -> -inf
+    // - libm : lgamma(-inf) -> inf
+
+    if (__builtin_isinf(x)) {
+        return x;
+    }
+
+    return lgamma(x);
+}
+
+double j0(double x);
+
+double __nac3_j0(double x) {
+    // libm's handling of value overflows differs from scipy:
+    // - scipy: j0(inf) -> nan
+    // - libm : j0(inf) -> 0.0
+
+    if (__builtin_isinf(x)) {
+        return __builtin_nan("");
+    }
+
+    return j0(x);
+}
+}
--- a/nac3core/irrt/irrt/math_util.hpp
+++ b/nac3core/irrt/irrt/math_util.hpp
@ -0,0 +1,13 @@
+#pragma once
+
+namespace {
+template<typename T>
+const T& max(const T& a, const T& b) {
+    return a > b ? a : b;
+}
+
+template<typename T>
+const T& min(const T& a, const T& b) {
+    return a > b ? b : a;
+}
+}  // namespace
--- a/nac3core/irrt/irrt/ndarray.hpp
+++ b/nac3core/irrt/irrt/ndarray.hpp
@ -0,0 +1,144 @@
+#pragma once
+
+#include "irrt/int_types.hpp"
+
+namespace {
+template<typename SizeT>
+SizeT __nac3_ndarray_calc_size_impl(const SizeT* list_data, SizeT list_len, SizeT begin_idx, SizeT end_idx) {
+    __builtin_assume(end_idx <= list_len);
+
+    SizeT num_elems = 1;
+    for (SizeT i = begin_idx; i < end_idx; ++i) {
+        SizeT val = list_data[i];
+        __builtin_assume(val > 0);
+        num_elems *= val;
+    }
+    return num_elems;
+}
+
+template<typename SizeT>
+void __nac3_ndarray_calc_nd_indices_impl(SizeT index, const SizeT* dims, SizeT num_dims, NDIndex* idxs) {
+    SizeT stride = 1;
+    for (SizeT dim = 0; dim < num_dims; dim++) {
+        SizeT i = num_dims - dim - 1;
+        __builtin_assume(dims[i] > 0);
+        idxs[i] = (index / stride) % dims[i];
+        stride *= dims[i];
+    }
+}
+
+template<typename SizeT>
+SizeT __nac3_ndarray_flatten_index_impl(const SizeT* dims, SizeT num_dims, const NDIndex* indices, SizeT num_indices) {
+    SizeT idx = 0;
+    SizeT stride = 1;
+    for (SizeT i = 0; i < num_dims; ++i) {
+        SizeT ri = num_dims - i - 1;
+        if (ri < num_indices) {
+            idx += stride * indices[ri];
+        }
+
+        __builtin_assume(dims[i] > 0);
+        stride *= dims[ri];
+    }
+    return idx;
+}
+
+template<typename SizeT>
+void __nac3_ndarray_calc_broadcast_impl(const SizeT* lhs_dims,
+                                        SizeT lhs_ndims,
+                                        const SizeT* rhs_dims,
+                                        SizeT rhs_ndims,
+                                        SizeT* out_dims) {
+    SizeT max_ndims = lhs_ndims > rhs_ndims ? lhs_ndims : rhs_ndims;
+
+    for (SizeT i = 0; i < max_ndims; ++i) {
+        const SizeT* lhs_dim_sz = i < lhs_ndims ? &lhs_dims[lhs_ndims - i - 1] : nullptr;
+        const SizeT* rhs_dim_sz = i < rhs_ndims ? &rhs_dims[rhs_ndims - i - 1] : nullptr;
+        SizeT* out_dim = &out_dims[max_ndims - i - 1];
+
+        if (lhs_dim_sz == nullptr) {
+            *out_dim = *rhs_dim_sz;
+        } else if (rhs_dim_sz == nullptr) {
+            *out_dim = *lhs_dim_sz;
+        } else if (*lhs_dim_sz == 1) {
+            *out_dim = *rhs_dim_sz;
+        } else if (*rhs_dim_sz == 1) {
+            *out_dim = *lhs_dim_sz;
+        } else if (*lhs_dim_sz == *rhs_dim_sz) {
+            *out_dim = *lhs_dim_sz;
+        } else {
+            __builtin_unreachable();
+        }
+    }
+}
+
+template<typename SizeT>
+void __nac3_ndarray_calc_broadcast_idx_impl(const SizeT* src_dims,
+                                            SizeT src_ndims,
+                                            const NDIndex* in_idx,
+                                            NDIndex* out_idx) {
+    for (SizeT i = 0; i < src_ndims; ++i) {
+        SizeT src_i = src_ndims - i - 1;
+        out_idx[src_i] = src_dims[src_i] == 1 ? 0 : in_idx[src_i];
+    }
+}
+}  // namespace
+
+extern "C" {
+uint32_t __nac3_ndarray_calc_size(const uint32_t* list_data, uint32_t list_len, uint32_t begin_idx, uint32_t end_idx) {
+    return __nac3_ndarray_calc_size_impl(list_data, list_len, begin_idx, end_idx);
+}
+
+uint64_t
+__nac3_ndarray_calc_size64(const uint64_t* list_data, uint64_t list_len, uint64_t begin_idx, uint64_t end_idx) {
+    return __nac3_ndarray_calc_size_impl(list_data, list_len, begin_idx, end_idx);
+}
+
+void __nac3_ndarray_calc_nd_indices(uint32_t index, const uint32_t* dims, uint32_t num_dims, NDIndex* idxs) {
+    __nac3_ndarray_calc_nd_indices_impl(index, dims, num_dims, idxs);
+}
+
+void __nac3_ndarray_calc_nd_indices64(uint64_t index, const uint64_t* dims, uint64_t num_dims, NDIndex* idxs) {
+    __nac3_ndarray_calc_nd_indices_impl(index, dims, num_dims, idxs);
+}
+
+uint32_t
+__nac3_ndarray_flatten_index(const uint32_t* dims, uint32_t num_dims, const NDIndex* indices, uint32_t num_indices) {
+    return __nac3_ndarray_flatten_index_impl(dims, num_dims, indices, num_indices);
+}
+
+uint64_t
+__nac3_ndarray_flatten_index64(const uint64_t* dims, uint64_t num_dims, const NDIndex* indices, uint64_t num_indices) {
+    return __nac3_ndarray_flatten_index_impl(dims, num_dims, indices, num_indices);
+}
+
+void __nac3_ndarray_calc_broadcast(const uint32_t* lhs_dims,
+                                   uint32_t lhs_ndims,
+                                   const uint32_t* rhs_dims,
+                                   uint32_t rhs_ndims,
+                                   uint32_t* out_dims) {
+    return __nac3_ndarray_calc_broadcast_impl(lhs_dims, lhs_ndims, rhs_dims, rhs_ndims, out_dims);
+}
+
+void __nac3_ndarray_calc_broadcast64(const uint64_t* lhs_dims,
+                                     uint64_t lhs_ndims,
+                                     const uint64_t* rhs_dims,
+                                     uint64_t rhs_ndims,
+                                     uint64_t* out_dims) {
+    return __nac3_ndarray_calc_broadcast_impl(lhs_dims, lhs_ndims, rhs_dims, rhs_ndims, out_dims);
+}
+
+void __nac3_ndarray_calc_broadcast_idx(const uint32_t* src_dims,
+                                       uint32_t src_ndims,
+                                       const NDIndex* in_idx,
+                                       NDIndex* out_idx) {
+    __nac3_ndarray_calc_broadcast_idx_impl(src_dims, src_ndims, in_idx, out_idx);
+}
+
+void __nac3_ndarray_calc_broadcast_idx64(const uint64_t* src_dims,
+                                         uint64_t src_ndims,
+                                         const NDIndex* in_idx,
+                                         NDIndex* out_idx) {
+    __nac3_ndarray_calc_broadcast_idx_impl(src_dims, src_ndims, in_idx, out_idx);
+}
+}
--- a/nac3core/irrt/irrt/slice.hpp
+++ b/nac3core/irrt/irrt/slice.hpp
@ -0,0 +1,28 @@
+#pragma once
+
+#include "irrt/int_types.hpp"
+
+extern "C" {
+SliceIndex __nac3_slice_index_bound(SliceIndex i, const SliceIndex len) {
+    if (i < 0) {
+        i = len + i;
+    }
+    if (i < 0) {
+        return 0;
+    } else if (i > len) {
+        return len;
+    }
+    return i;
+}
+
+SliceIndex __nac3_range_slice_len(const SliceIndex start, const SliceIndex end, const SliceIndex step) {
+    SliceIndex diff = end - start;
+    if (diff > 0 && step > 0) {
+        return ((diff - 1) / step) + 1;
+    } else if (diff < 0 && step < 0) {
+        return ((diff + 1) / step) + 1;
+    } else {
+        return 0;
+    }
+}
+}
--- a/nac3core/irrt/irrt_basic.hpp
+++ b/nac3core/irrt/irrt_basic.hpp
@ -1,216 +0,0 @@
-#pragma once
-
-#include "irrt_utils.hpp"
-#include "irrt_typedefs.hpp"
-
-/*
-    This header contains IRRT implementations
-    that do not deserved to be categorized (e.g., into numpy, etc.)
-
-    Check out other *.hpp files before including them here!!
-*/
-
-// The type of an index or a value describing the length of a range/slice is
-// always `int32_t`.
-
-namespace {
-    // adapted from GNU Scientific Library: https://git.savannah.gnu.org/cgit/gsl.git/tree/sys/pow_int.c
-    // need to make sure `exp >= 0` before calling this function
-    template <typename T>
-    T __nac3_int_exp_impl(T base, T exp) {
-        T res = 1;
-        /* repeated squaring method */
-        do {
-            if (exp & 1) {
-                res *= base; /* for n odd */
-            }
-            exp >>= 1;
-            base *= base;
-        } while (exp);
-        return res;
-    }
-}
-
-extern "C" {
-    #define DEF_nac3_int_exp_(T) \
-        T __nac3_int_exp_##T(T base, T exp) {\
-            return __nac3_int_exp_impl(base, exp);\
-        }
-
-    DEF_nac3_int_exp_(int32_t)
-    DEF_nac3_int_exp_(int64_t)
-    DEF_nac3_int_exp_(uint32_t)
-    DEF_nac3_int_exp_(uint64_t)
-
-    SliceIndex __nac3_slice_index_bound(SliceIndex i, const SliceIndex len) {
-        if (i < 0) {
-            i = len + i;
-        }
-        if (i < 0) {
-            return 0;
-        } else if (i > len) {
-            return len;
-        }
-        return i;
-    }
-
-    SliceIndex __nac3_range_slice_len(
-        const SliceIndex start,
-        const SliceIndex end,
-        const SliceIndex step
-    ) {
-        SliceIndex diff = end - start;
-        if (diff > 0 && step > 0) {
-            return ((diff - 1) / step) + 1;
-        } else if (diff < 0 && step < 0) {
-            return ((diff + 1) / step) + 1;
-        } else {
-            return 0;
-        }
-    }
-
-    // Handle list assignment and dropping part of the list when
-    // both dest_step and src_step are +1.
-    // - All the index must *not* be out-of-bound or negative,
-    // - The end index is *inclusive*,
-    // - The length of src and dest slice size should already
-    // be checked: if dest.step == 1 then len(src) <= len(dest) else len(src) == len(dest)
-    SliceIndex __nac3_list_slice_assign_var_size(
-        SliceIndex dest_start,
-        SliceIndex dest_end,
-        SliceIndex dest_step,
-        uint8_t *dest_arr,
-        SliceIndex dest_arr_len,
-        SliceIndex src_start,
-        SliceIndex src_end,
-        SliceIndex src_step,
-        uint8_t *src_arr,
-        SliceIndex src_arr_len,
-        const SliceIndex size
-    ) {
-        /* if dest_arr_len == 0, do nothing since we do not support extending list */
-        if (dest_arr_len == 0) return dest_arr_len;
-        /* if both step is 1, memmove directly, handle the dropping of the list, and shrink size */
-        if (src_step == dest_step && dest_step == 1) {
-            const SliceIndex src_len = (src_end >= src_start) ? (src_end - src_start + 1) : 0;
-            const SliceIndex dest_len = (dest_end >= dest_start) ? (dest_end - dest_start + 1) : 0;
-            if (src_len > 0) {
-                __builtin_memmove(
-                    dest_arr + dest_start * size,
-                    src_arr + src_start * size,
-                    src_len * size
-                );
-            }
-            if (dest_len > 0) {
-                /* dropping */
-                __builtin_memmove(
-                    dest_arr + (dest_start + src_len) * size,
-                    dest_arr + (dest_end + 1) * size,
-                    (dest_arr_len - dest_end - 1) * size
-                );
-            }
-            /* shrink size */
-            return dest_arr_len - (dest_len - src_len);
-        }
-        /* if two range overlaps, need alloca */
-        uint8_t need_alloca =
-            (dest_arr == src_arr)
-            && !(
-                max(dest_start, dest_end) < min(src_start, src_end)
-                || max(src_start, src_end) < min(dest_start, dest_end)
-            );
-        if (need_alloca) {
-            uint8_t *tmp = reinterpret_cast<uint8_t *>(__builtin_alloca(src_arr_len * size));
-            __builtin_memcpy(tmp, src_arr, src_arr_len * size);
-            src_arr = tmp;
-        }
-        SliceIndex src_ind = src_start;
-        SliceIndex dest_ind = dest_start;
-        for (;
-            (src_step > 0) ? (src_ind <= src_end) : (src_ind >= src_end);
-            src_ind += src_step, dest_ind += dest_step
-        ) {
-            /* for constant optimization */
-            if (size == 1) {
-                __builtin_memcpy(dest_arr + dest_ind, src_arr + src_ind, 1);
-            } else if (size == 4) {
-                __builtin_memcpy(dest_arr + dest_ind * 4, src_arr + src_ind * 4, 4);
-            } else if (size == 8) {
-                __builtin_memcpy(dest_arr + dest_ind * 8, src_arr + src_ind * 8, 8);
-            } else {
-                /* memcpy for var size, cannot overlap after previous alloca */
-                __builtin_memcpy(dest_arr + dest_ind * size, src_arr + src_ind * size, size);
-            }
-        }
-        /* only dest_step == 1 can we shrink the dest list. */
-        /* size should be ensured prior to calling this function */
-        if (dest_step == 1 && dest_end >= dest_start) {
-            __builtin_memmove(
-                dest_arr + dest_ind * size,
-                dest_arr + (dest_end + 1) * size,
-                (dest_arr_len - dest_end - 1) * size
-            );
-            return dest_arr_len - (dest_end - dest_ind) - 1;
-        }
-        return dest_arr_len;
-    }
-
-    int32_t __nac3_isinf(double x) {
-        return __builtin_isinf(x);
-    }
-
-    int32_t __nac3_isnan(double x) {
-        return __builtin_isnan(x);
-    }
-
-    double tgamma(double arg);
-
-    double __nac3_gamma(double z) {
-        // Handling for denormals
-        //     | x                 | Python gamma(x) | C tgamma(x) |
-        // --- | ----------------- | --------------- | ----------- |
-        // (1) | nan               | nan             | nan         |
-        // (2) | -inf              | -inf            | inf         |
-        // (3) | inf               | inf             | inf         |
-        // (4) | 0.0               | inf             | inf         |
-        // (5) | {-1.0, -2.0, ...} | inf             | nan         |
-
-        // (1)-(3)
-        if (__builtin_isinf(z) || __builtin_isnan(z)) {
-            return z;
-        }
-
-        double v = tgamma(z);
-
-        // (4)-(5)
-        return __builtin_isinf(v) || __builtin_isnan(v) ? __builtin_inf() : v;
-    }
-
-    double lgamma(double arg);
-
-    double __nac3_gammaln(double x) {
-        // libm's handling of value overflows differs from scipy:
-        // - scipy: gammaln(-inf) -> -inf
-        // - libm : lgamma(-inf) -> inf
-
-        if (__builtin_isinf(x)) {
-            return x;
-        }
-
-        return lgamma(x);
-    }
-
-    double j0(double x);
-
-    double __nac3_j0(double x) {
-        // libm's handling of value overflows differs from scipy:
-        // - scipy: j0(inf) -> nan
-        // - libm : j0(inf) -> 0.0
-
-        if (__builtin_isinf(x)) {
-            return __builtin_nan("");
-        }
-
-        return j0(x);
-    }
-}
--- a/nac3core/irrt/irrt_everything.hpp
+++ b/nac3core/irrt/irrt_everything.hpp
@ -1,14 +0,0 @@
-#pragma once
-
-#include "irrt_utils.hpp"
-#include "irrt_typedefs.hpp"
-#include "irrt_basic.hpp"
-#include "irrt_slice.hpp"
-#include "irrt_numpy_ndarray.hpp"
-
-/*
-    All IRRT implementations.
-
-    We don't have any pre-compiled objects, so we are writing all implementations in headers and
-    concatenate them with `#include` into one massive source file that contains all the IRRT stuff.
-*/
--- a/nac3core/irrt/irrt_numpy_ndarray.hpp
+++ b/nac3core/irrt/irrt_numpy_ndarray.hpp
@ -1,466 +0,0 @@
-#pragma once
-
-#include "irrt_utils.hpp"
-#include "irrt_typedefs.hpp"
-#include "irrt_slice.hpp"
-
-/*
-    NDArray-related implementations.
-`*/
-
-// NDArray indices are always `uint32_t`.
-using NDIndex = uint32_t;
-
-namespace {
-    namespace ndarray_util {
-        template <typename SizeT>
-        static void set_indices_by_nth(SizeT ndims, const SizeT* shape, SizeT* indices, SizeT nth) {
-            for (int32_t i = 0; i < ndims; i++) {
-                int32_t dim_i = ndims - i - 1;
-                int32_t dim = shape[dim_i];
-
-                indices[dim_i] = nth % dim;
-                nth /= dim;
-            }
-        }
-
-        // Compute the strides of an ndarray given an ndarray `shape`
-        // and assuming that the ndarray is *fully C-contagious*.
-        //
-        // You might want to read up on https://ajcr.net/stride-guide-part-1/.
-        template <typename SizeT>
-        static void set_strides_by_shape(SizeT itemsize, SizeT ndims, SizeT* dst_strides, const SizeT* shape) {
-            SizeT stride_product = 1;
-            for (SizeT i = 0; i < ndims; i++) {
-                int dim_i = ndims - i - 1;
-                dst_strides[dim_i] = stride_product * itemsize;
-                stride_product *= shape[dim_i];
-            }
-        }
-
-        // Compute the size/# of elements of an ndarray given its shape
-        template <typename SizeT>
-        static SizeT calc_size_from_shape(SizeT ndims, const SizeT* shape) {
-            SizeT size = 1;
-            for (SizeT dim_i = 0; dim_i < ndims; dim_i++) size *= shape[dim_i];
-            return size;
-        }
-
-        template <typename SizeT>
-        static bool can_broadcast_shape_to(
-            const SizeT target_ndims,
-            const SizeT *target_shape,
-            const SizeT src_ndims,
-            const SizeT *src_shape
-        ) {
-            /*
-                // See https://numpy.org/doc/stable/user/basics.broadcasting.html
-
-                This function handles this example:
-                ```
-                Image  (3d array): 256 x 256 x 3
-                Scale  (1d array):             3
-                Result (3d array): 256 x 256 x 3
-                ```
-
-                Other interesting examples to consider:
-                - `can_broadcast_shape_to([3], [1, 1, 1, 1, 3]) == true`
-                - `can_broadcast_shape_to([3], [3, 1]) == false`
-                - `can_broadcast_shape_to([256, 256, 3], [256, 1, 3]) == true`
-
-                In cases when the shapes contain zero(es):
-                - `can_broadcast_shape_to([0], [1]) == true`
-                - `can_broadcast_shape_to([0], [2]) == false`
-                - `can_broadcast_shape_to([0, 4, 0, 0], [1]) == true`
-                - `can_broadcast_shape_to([0, 4, 0, 0], [1, 1, 1, 1]) == true`
-                - `can_broadcast_shape_to([0, 4, 0, 0], [1, 4, 1, 1]) == true`
-                - `can_broadcast_shape_to([4, 3], [0, 3]) == false`
-                - `can_broadcast_shape_to([4, 3], [0, 0]) == false`
-            */
-
-            // This is essentially doing the following in Python:
-            // `for target_dim, src_dim in itertools.zip_longest(target_shape[::-1], src_shape[::-1], fillvalue=1)`
-            for (SizeT i = 0; i < max(target_ndims, src_ndims); i++) {
-                SizeT target_dim_i = target_ndims - i - 1;
-                SizeT src_dim_i = src_ndims - i - 1;
-
-                bool target_dim_exists = target_dim_i >= 0;
-                bool src_dim_exists = src_dim_i >= 0;
-
-                SizeT target_dim = target_dim_exists ? target_shape[target_dim_i] : 1;
-                SizeT src_dim = src_dim_exists ? src_shape[src_dim_i] : 1;
-
-                bool ok = src_dim == 1 || target_dim == src_dim;
-                if (!ok) return false;
-            }
-
-            return true;
-        }
-    }
-
-    typedef uint8_t NDSliceType;
-    extern "C" {
-        const NDSliceType INPUT_SLICE_TYPE_INDEX = 0;
-        const NDSliceType INPUT_SLICE_TYPE_SLICE = 1;
-    }
-
-    struct NDSlice {
-        // A poor-man's `std::variant<int, UserRange>`
-        NDSliceType type;
-
-        /*
-            if type == INPUT_SLICE_TYPE_INDEX => `slice` points to a single `SizeT`
-            if type == INPUT_SLICE_TYPE_SLICE => `slice` points to a single `UserRange`
-        */
-        uint8_t *slice;
-    };
-
-    namespace ndarray_util {
-        template<typename SizeT>
-        SizeT deduce_ndims_after_slicing(SizeT ndims, SizeT num_slices, const NDSlice *slices) {
-            irrt_assert(num_slices <= ndims);
-
-            SizeT final_ndims = ndims;
-            for (SizeT i = 0; i < num_slices; i++) {
-                if (slices[i].type == INPUT_SLICE_TYPE_INDEX) {
-                    final_ndims--; // An integer slice demotes the rank by 1
-                }
-            }
-            return final_ndims;
-        }
-    }
-
-    template <typename SizeT>
-    struct NDArrayIndicesIter {
-        SizeT ndims;
-        const SizeT *shape;
-        SizeT *indices;
-
-        void set_indices_zero() {
-            __builtin_memset(indices, 0, sizeof(SizeT) * ndims);
-        }
-
-        void next() {
-            for (SizeT i = 0; i < ndims; i++) {
-                SizeT dim_i = ndims - i - 1;
-
-                indices[dim_i]++;
-                if (indices[dim_i] < shape[dim_i]) {
-                    break;
-                } else {
-                    indices[dim_i] = 0;
-                }
-            }
-        }
-    };
-
-    // The NDArray object. `SizeT` is the *signed* size type of this ndarray.
-    //
-    // NOTE: The order of fields is IMPORTANT. DON'T TOUCH IT
-    //
-    // Some resources you might find helpful:
-    // - The official numpy implementations:
-    //   - https://github.com/numpy/numpy/blob/735a477f0bc2b5b84d0e72d92f224bde78d4e069/doc/source/reference/c-api/types-and-structures.rst
-    // - On strides (about reshaping, slicing, C-contagiousness, etc)
-    //   - https://ajcr.net/stride-guide-part-1/.
-    //   - https://ajcr.net/stride-guide-part-2/.
-    //   - https://ajcr.net/stride-guide-part-3/.
-    template <typename SizeT>
-    struct NDArray {
-        // The underlying data this `ndarray` is pointing to.
-        //
-        // NOTE: Formally this should be of type `void *`, but clang
-        // translates `void *` to `i8 *` when run with `-S -emit-llvm`,
-        // so we will put `uint8_t *` here for clarity.
-        uint8_t *data;
-
-        // The number of bytes of a single element in `data`.
-        //
-        // The `SizeT` is treated as `unsigned`.
-        SizeT itemsize;
-
-        // The number of dimensions of this shape.
-        //
-        // The `SizeT` is treated as `unsigned`.
-        SizeT ndims;
-
-        // Array shape, with length equal to `ndims`.
-        //
-        // The `SizeT` is treated as `unsigned`.
-        //
-        // NOTE: `shape` can contain 0.
-        //   (those appear when the user makes an out of bounds slice into an ndarray, e.g., `np.zeros((3, 3))[400:].shape == (0, 3)`)
-        SizeT *shape;
-
-        // Array strides (stride value is in number of bytes, NOT number of elements), with length equal to `ndims`.
-        //
-        // The `SizeT` is treated as `signed`.
-        //
-        // NOTE: `strides` can have negative numbers.
-        //   (those appear when there is a slice with a negative step, e.g., `my_array[::-1]`)
-        SizeT *strides;
-
-        // Calculate the size/# of elements of an `ndarray`.
-        // This function corresponds to `np.size(<ndarray>)` or `ndarray.size`
-        SizeT size() {
-            return ndarray_util::calc_size_from_shape(ndims, shape);
-        }
-
-        // Calculate the number of bytes of its content of an `ndarray` *in its view*.
-        // This function corresponds to `ndarray.nbytes`
-        SizeT nbytes() {
-            return this->size() * itemsize;
-        }
-
-        void set_value_at_pelement(uint8_t* pelement, const uint8_t* pvalue) {
-            __builtin_memcpy(pelement, pvalue, itemsize);
-        }
-
-        uint8_t* get_pelement(const SizeT *indices) {
-            uint8_t* element = data;
-            for (SizeT dim_i = 0; dim_i < ndims; dim_i++)
-                element += indices[dim_i] * strides[dim_i];
-            return element;
-        }
-
-        uint8_t* get_nth_pelement(SizeT nth) {
-            irrt_assert(0 <= nth);
-            irrt_assert(nth < this->size());
-
-            SizeT* indices = (SizeT*) __builtin_alloca(sizeof(SizeT) * this->ndims);
-            ndarray_util::set_indices_by_nth(this->ndims, this->shape, indices, nth);
-            return get_pelement(indices);
-        }
-
-        // Get pointer to the first element of this ndarray, assuming
-        // `this->size() > 0`, i.e., not "degenerate" due to zeroes in `this->shape`)
-        //
-        // This is particularly useful for when the ndarray is just containing a single scalar.
-        uint8_t* get_first_pelement() {
-            irrt_assert(this->size() > 0);
-            return this->data; // ...It is simply `this->data`
-        }
-
-        // Is the given `indices` valid/in-bounds?
-        bool in_bounds(const SizeT *indices) {
-            for (SizeT dim_i = 0; dim_i < ndims; dim_i++) {
-                bool dim_ok = indices[dim_i] < shape[dim_i];
-                if (!dim_ok) return false;
-            }
-            return true;
-        }
-
-        // Fill the ndarray with a value
-        void fill_generic(const uint8_t* pvalue) {
-            NDArrayIndicesIter<SizeT> iter;
-            iter.ndims = this->ndims;
-            iter.shape = this->shape;
-            iter.indices = (SizeT*) __builtin_alloca(sizeof(SizeT) * ndims);
-            iter.set_indices_zero();
-
-            for (SizeT i = 0; i < this->size(); i++, iter.next()) {
-                uint8_t* pelement = get_pelement(iter.indices);
-                set_value_at_pelement(pelement, pvalue);
-            }
-        }
-
-        // Set the strides of the ndarray with `ndarray_util::set_strides_by_shape`
-        void set_strides_by_shape() {
-            ndarray_util::set_strides_by_shape(itemsize, ndims, strides, shape);
-        }
-
-        // https://numpy.org/doc/stable/reference/generated/numpy.eye.html
-        void set_to_eye(SizeT k, const uint8_t* zero_pvalue, const uint8_t* one_pvalue) {
-            __builtin_assume(ndims == 2);
-
-            // TODO: Better implementation
-
-            fill_generic(zero_pvalue);
-            for (SizeT i = 0; i < min(shape[0], shape[1]); i++) {
-                SizeT row = i;
-                SizeT col = i + k;
-                SizeT indices[2] = { row, col };
-
-                if (!in_bounds(indices)) continue;
-
-                uint8_t* pelement = get_pelement(indices);
-                set_value_at_pelement(pelement, one_pvalue);
-            }
-        }
-
-        // To support numpy complex slices (e.g., `my_array[:50:2,4,:2:-1]`)
-        //
-        // Things assumed by this function:
-        // - `dst_ndarray` is allocated by the caller
-        // - `dst_ndarray.ndims` has the correct value (according to `ndarray_util::deduce_ndims_after_slicing`).
-        //   - ... and `dst_ndarray.shape` and `dst_ndarray.strides` have been allocated by the caller as well
-        //
-        // Other notes:
-        // - `dst_ndarray->data` does not have to be set, it will be derived.
-        // - `dst_ndarray->itemsize` does not have to be set, it will be set to `this->itemsize`
-        // - `dst_ndarray->shape` and `dst_ndarray.strides` can contain empty values
-        void slice(SizeT num_ndslices, NDSlice* ndslices, NDArray<SizeT>* dst_ndarray) {
-            // REFERENCE CODE (check out `_index_helper` in `__getitem__`):
-            //   https://github.com/wadetb/tinynumpy/blob/0d23d22e07062ffab2afa287374c7b366eebdda1/tinynumpy/tinynumpy.py#L652
-
-            irrt_assert(dst_ndarray->ndims == ndarray_util::deduce_ndims_after_slicing(this->ndims, num_ndslices, ndslices));
-
-            dst_ndarray->data = this->data;
-
-            SizeT this_axis = 0;
-            SizeT dst_axis = 0;
-
-            for (SizeT i = 0; i < num_ndslices; i++) {
-                NDSlice *ndslice = &ndslices[i];
-                if (ndslice->type == INPUT_SLICE_TYPE_INDEX) {
-                    // Handle when the ndslice is just a single (possibly negative) integer
-                    // e.g., `my_array[::2, -5, ::-1]`
-                    //                      ^^------ like this
-                    SizeT index_user = *((SizeT*) ndslice->slice);
-                    SizeT index = resolve_index_in_length(this->shape[this_axis], index_user);
-                    dst_ndarray->data += index * this->strides[this_axis]; // Add offset
-
-                    // Next
-                    this_axis++;
-                } else if (ndslice->type == INPUT_SLICE_TYPE_SLICE) {
-                    // Handle when the ndslice is a slice (represented by UserSlice in IRRT)
-                    // e.g., `my_array[::2, -5, ::-1]`
-                    //                 ^^^------^^^^----- like these
-                    UserSlice<SizeT>* user_slice = (UserSlice<SizeT>*) ndslice->slice;
-                    Slice<SizeT> slice = user_slice->indices(this->shape[this_axis]); // To resolve negative indices and other funny stuff written by the user
-
-                    // NOTE: There is no need to write special code to handle negative steps/strides.
-                    // This simple implementation meticulously handles both positive and negative steps/strides.
-                    // Check out the tinynumpy and IRRT's test cases if you are not convinced.
-                    dst_ndarray->data += slice.start * this->strides[this_axis]; // Add offset (NOTE: no need to `* itemsize`, strides count in # of bytes)
-                    dst_ndarray->strides[dst_axis] = slice.step * this->strides[this_axis]; // Determine stride
-                    dst_ndarray->shape[dst_axis] = slice.len(); // Determine shape dimension
-
-                    // Next
-                    dst_axis++;
-                    this_axis++;
-                } else {
-                    __builtin_unreachable();
-                }
-            }
-
-            irrt_assert(dst_axis == dst_ndarray->ndims); // Sanity check on the implementation
-        }
-
-        // Similar to `np.broadcast_to(<ndarray>, <target_shape>)`
-        // Assumptions:
-        //   - `this` has to be fully initialized.
-        //   - `dst_ndarray->ndims` has to be set.
-        //   - `dst_ndarray->shape` has to be set, this determines the shape `this` broadcasts to.
-        //
-        // Other notes:
-        //   - `dst_ndarray->data` does not have to be set, it will be set to `this->data`.
-        //   - `dst_ndarray->itemsize` does not have to be set, it will be set to `this->data`.
-        //   - `dst_ndarray->strides` does not have to be set, it will be overwritten.
-        //
-        // Cautions:
-        //   ```
-        //   xs = np.zeros((4,))
-        //   ys = np.zero((4, 1))
-        //   ys[:] = xs # ok
-        // 
-        //   xs = np.zeros((1, 4))
-        //   ys = np.zero((4,))
-        //   ys[:] = xs # allowed
-        //   # However `np.broadcast_to(xs, (4,))` would fails, as per numpy's broadcasting rule.
-        //   # and apparently numpy will "deprecate" this? SEE https://github.com/numpy/numpy/issues/21744
-        //   # This implementation will NOT support this assignment.
-        //   ```
-        void broadcast_to(NDArray<SizeT>* dst_ndarray) {
-            dst_ndarray->data = this->data;
-            dst_ndarray->itemsize = this->itemsize;
-
-            irrt_assert(
-                ndarray_util::can_broadcast_shape_to(
-                    dst_ndarray->ndims,
-                    dst_ndarray->shape,
-                    this->ndims,
-                    this->shape
-                )
-            );
-
-            SizeT stride_product = 1;
-            for (SizeT i = 0; i < max(this->ndims, dst_ndarray->ndims); i++) {
-                SizeT this_dim_i = this->ndims - i - 1;
-                SizeT dst_dim_i = dst_ndarray->ndims - i - 1;
-
-                bool this_dim_exists = this_dim_i >= 0;
-                bool dst_dim_exists = dst_dim_i >= 0;
-
-                // TODO: Explain how this works
-                bool c1 = this_dim_exists && this->shape[this_dim_i] == 1;
-                bool c2 = dst_dim_exists && dst_ndarray->shape[dst_dim_i] != 1;
-                if (!this_dim_exists || (c1 && c2)) {
-                    dst_ndarray->strides[dst_dim_i] = 0; // Freeze it in-place
-                } else {
-                    dst_ndarray->strides[dst_dim_i] = stride_product * this->itemsize;
-                    stride_product *= this->shape[this_dim_i]; // NOTE: this_dim_exist must be true here.
-                }
-            }
-        }
-
-        // Simulates `this_ndarray[:] = src_ndarray`, with automatic broadcasting.
-        // Caution on https://github.com/numpy/numpy/issues/21744
-        // Also see `NDArray::broadcast_to`
-        void assign_with(NDArray<SizeT>* src_ndarray) {
-            irrt_assert(
-                ndarray_util::can_broadcast_shape_to(
-                    this->ndims,
-                    this->shape,
-                    src_ndarray->ndims,
-                    src_ndarray->shape
-                )
-            );
-
-            // Broadcast the `src_ndarray` to make the reading process *much* easier
-            SizeT* broadcasted_src_ndarray_strides = __builtin_alloca(sizeof(SizeT) * this->ndims); // Remember to allocate strides beforehand
-            NDArray<SizeT> broadcasted_src_ndarray = {
-                .ndims = this->ndims,
-                .shape = this->shape,
-                .strides = broadcasted_src_ndarray_strides
-            };
-            src_ndarray->broadcast_to(&broadcasted_src_ndarray);
-
-            // Using iter instead of `get_nth_pelement` because it is slightly faster
-            SizeT* indices = __builtin_alloca(sizeof(SizeT) * this->ndims);
-            auto iter = NDArrayIndicesIter<SizeT> {
-                .ndims = this->ndims,
-                .shape = this->shape,
-                .indices = indices
-            };
-            const SizeT this_size = this->size();
-            for (SizeT i = 0; i < this_size; i++, iter.next()) {
-                uint8_t* src_pelement = broadcasted_src_ndarray_strides->get_pelement(indices);
-                uint8_t* this_pelement = this->get_pelement(indices);
-                this->set_value_at_pelement(src_pelement, src_pelement);
-            }
-        }
-    };
-}
-
-extern "C" {
-    uint32_t __nac3_ndarray_size(NDArray<int32_t>* ndarray) {
-        return ndarray->size();
-    }
-
-    uint64_t __nac3_ndarray_size64(NDArray<int64_t>* ndarray) {
-        return ndarray->size();
-    }
-
-    void __nac3_ndarray_fill_generic(NDArray<int32_t>* ndarray, uint8_t* pvalue) {
-        ndarray->fill_generic(pvalue);
-    }
-
-    void __nac3_ndarray_fill_generic64(NDArray<int64_t>* ndarray, uint8_t* pvalue) {
-        ndarray->fill_generic(pvalue);
-    }
-
-    // void __nac3_ndarray_slice(NDArray<int32_t>* ndarray, int32_t num_slices, NDSlice<int32_t> *slices, NDArray<int32_t> *dst_ndarray) {
-    //     // ndarray->slice(num_slices, slices, dst_ndarray);
-    // }
-}
--- a/nac3core/irrt/irrt_slice.hpp
+++ b/nac3core/irrt/irrt_slice.hpp
@ -1,80 +0,0 @@
-#pragma once
-
-#include "irrt_utils.hpp"
-#include "irrt_typedefs.hpp"
-
-namespace {
-    // A proper slice in IRRT, all negative indices have be resolved to absolute values.
-    // Even though nac3core's slices are always `int32_t`, we will template slice anyway
-    // since this struct is used as a general utility.
-    template <typename T>
-    struct Slice {
-        T start;
-        T stop;
-        T step;
-
-        // The length/The number of elements of the slice if it were a range,
-        // i.e., the value of `len(range(this->start, this->stop, this->end))`
-        T len() {
-            T diff = stop - start;
-            if (diff > 0 && step > 0) {
-                return ((diff - 1) / step) + 1;
-            } else if (diff < 0 && step < 0) {
-                return ((diff + 1) / step) + 1;
-            } else {
-                return 0;
-            }
-        }
-    };
-
-    template<typename T>
-    T resolve_index_in_length(T length, T index) {
-        irrt_assert(length >= 0);
-        if (index < 0) {
-            // Remember that index is negative, so do a plus here
-            return max(length + index, 0);
-        } else {
-            return min(length, index);
-        }
-    }
-
-    // NOTE: using a bitfield for the `*_defined` is better, at the
-    // cost of a more annoying implementation in nac3core inkwell
-    template <typename T>
-    struct UserSlice {
-        uint8_t start_defined;
-        T start;
-
-        uint8_t stop_defined;
-        T stop;
-
-        uint8_t step_defined;
-        T step;
-
-        // Like Python's `slice(start, stop, step).indices(length)`
-        Slice<T> indices(T length) {
-            // NOTE: This function implements Python's `slice.indices` *FAITHFULLY*.
-            // SEE: https://github.com/python/cpython/blob/f62161837e68c1c77961435f1b954412dd5c2b65/Objects/sliceobject.c#L546
-            irrt_assert(length >= 0);
-            irrt_assert(!step_defined || step != 0); // step_defined -> step != 0; step cannot be zero if specified by user
-
-            Slice<T> result;
-            result.step = step_defined ? step : 1;
-            bool step_is_negative = result.step < 0;
-
-            if (start_defined) {
-                result.start = resolve_index_in_length(length, start);
-            } else {
-                result.start = step_is_negative ? length - 1 : 0;
-            }
-            
-            if (stop_defined) {
-                result.stop = resolve_index_in_length(length, stop);
-            } else {
-                result.stop = step_is_negative ? -1 : length;
-            }
-
-            return result;
-        }
-    };
-}
--- a/nac3core/irrt/irrt_test.cpp
+++ b/nac3core/irrt/irrt_test.cpp
@ -1,658 +0,0 @@
-// This file will be compiled like a real C++ program,
-// and we do have the luxury to use the standard libraries.
-// That is if the nix flakes do not have issues... especially on msys2...
-#include <cstdint>
-#include <cstdio>
-#include <cstdlib>
-
-// Set `IRRT_DONT_TYPEDEF_INTS` because `cstdint` defines them
-#define IRRT_DONT_TYPEDEF_INTS
-#include "irrt_everything.hpp"
-
-void test_fail() {
-    printf("[!] Test failed\n");
-    exit(1);
-}
-
-void __begin_test(const char* function_name, const char* file, int line) {
-    printf("######### Running %s @ %s:%d\n", function_name, file, line);
-}
-
-#define BEGIN_TEST() __begin_test(__FUNCTION__, __FILE__, __LINE__)
-
-template <typename T>
-void debug_print_array(const char* format, int len, T* as) {
-    printf("[");
-    for (int i = 0; i < len; i++) {
-        if (i != 0) printf(", ");
-        printf(format, as[i]);
-    }
-    printf("]");
-}
-
-template <typename T>
-void assert_arrays_match(const char* label, const char* format, int len, T* expected, T* got) {
-    if (!arrays_match(len, expected, got)) {
-        printf(">>>>>>> %s\n", label);
-        printf("    Expecting = ");
-        debug_print_array(format, len, expected);
-        printf("\n");
-        printf("          Got = ");
-        debug_print_array(format, len, got);
-        printf("\n");
-        test_fail();
-    }
-}
-
-template <typename T>
-void assert_values_match(const char* label, const char* format, T expected, T got) {
-    if (expected != got) {
-        printf(">>>>>>> %s\n", label);
-        printf("    Expecting = ");
-        printf(format, expected);
-        printf("\n");
-        printf("          Got = ");
-        printf(format, got);
-        printf("\n");
-        test_fail();
-    }
-}
-
-void print_repeated(const char *str, int count) {
-    for (int i = 0; i < count; i++) {
-        printf("%s", str);
-    }
-}
-
-template<typename SizeT, typename ElementT>
-void __print_ndarray_aux(const char *format, bool first, bool last, SizeT* cursor, SizeT depth, NDArray<SizeT>* ndarray) {
-    // A really lazy recursive implementation
-    
-    // Add left padding unless its the first entry (since there would be "[[[" before it)
-    if (!first) {
-        print_repeated(" ", depth);
-    }
-
-    const SizeT dim = ndarray->shape[depth];
-    if (depth + 1 == ndarray->ndims) {
-        // Recursed down to last dimension, print the values in a nice list
-        printf("[");
-
-        SizeT* indices = (SizeT*) __builtin_alloca(sizeof(SizeT) * ndarray->ndims);
-        for (SizeT i = 0; i < dim; i++) {
-            ndarray_util::set_indices_by_nth(ndarray->ndims, ndarray->shape, indices, *cursor);
-            ElementT* pelement = (ElementT*) ndarray->get_pelement(indices);
-            ElementT element = *pelement;
-
-            if (i != 0) printf(", "); // List delimiter
-            printf(format, element);
-            printf("(@");
-            debug_print_array("%d", ndarray->ndims, indices);
-            printf(")");
-
-            (*cursor)++;
-        }
-        printf("]");
-    } else {
-        printf("[");
-        for (SizeT i = 0; i < ndarray->shape[depth]; i++) {
-            __print_ndarray_aux<SizeT, ElementT>(
-                format,
-                i == 0, // first?
-                i + 1 == dim, // last?
-                cursor,
-                depth + 1,
-                ndarray
-            );
-        }
-        printf("]");
-    }
-
-    // Add newline unless its the last entry (since there will be "]]]" after it)
-    if (!last) {
-        print_repeated("\n", depth);
-    }
-}
-
-template<typename SizeT, typename ElementT>
-void print_ndarray(const char *format, NDArray<SizeT>* ndarray) {
-    if (ndarray->ndims == 0) {
-        printf("<empty ndarray>");
-    } else {
-        SizeT cursor = 0;
-        __print_ndarray_aux<SizeT, ElementT>(format, true, true, &cursor, 0, ndarray);
-    }
-    printf("\n");
-}
-
-void test_calc_size_from_shape_normal() {
-    // Test shapes with normal values
-    BEGIN_TEST();
-
-    int32_t shape[4] = { 2, 3, 5, 7 };
-    assert_values_match("size", "%d", 210, ndarray_util::calc_size_from_shape<int32_t>(4, shape));
-}
-
-void test_calc_size_from_shape_has_zero() {
-    // Test shapes with 0 in them
-    BEGIN_TEST();
-
-    int32_t shape[4] = { 2, 0, 5, 7 };
-    assert_values_match("size", "%d", 0, ndarray_util::calc_size_from_shape<int32_t>(4, shape));
-}
-
-void test_set_strides_by_shape() {
-    // Test `set_strides_by_shape()`
-    BEGIN_TEST();
-
-    int32_t shape[4] = { 99, 3, 5, 7 };
-    int32_t strides[4] = { 0 };
-    ndarray_util::set_strides_by_shape((int32_t) sizeof(int32_t), 4, strides, shape);
-
-    int32_t expected_strides[4] = {
-        105 * sizeof(int32_t),
-        35 * sizeof(int32_t),
-        7 * sizeof(int32_t),
-        1 * sizeof(int32_t)
-    };
-    assert_arrays_match("strides", "%u", 4u, expected_strides, strides);
-}
-
-void test_ndarray_indices_iter_normal() {
-    // Test NDArrayIndicesIter normal behavior
-    BEGIN_TEST();
-
-    int32_t shape[3] = { 1, 2, 3 };
-    int32_t indices[3] = { 0, 0, 0 };
-    auto iter = NDArrayIndicesIter<int32_t> {
-        .ndims = 3,
-        .shape = shape,
-        .indices = indices
-    };
-
-    assert_arrays_match("indices #0", "%u", 3u, iter.indices, (int32_t[3]) { 0, 0, 0 });
-    iter.next();
-    assert_arrays_match("indices #1", "%u", 3u, iter.indices, (int32_t[3]) { 0, 0, 1 });
-    iter.next();
-    assert_arrays_match("indices #2", "%u", 3u, iter.indices, (int32_t[3]) { 0, 0, 2 });
-    iter.next();
-    assert_arrays_match("indices #3", "%u", 3u, iter.indices, (int32_t[3]) { 0, 1, 0 });
-    iter.next();
-    assert_arrays_match("indices #4", "%u", 3u, iter.indices, (int32_t[3]) { 0, 1, 1 });
-    iter.next();
-    assert_arrays_match("indices #5", "%u", 3u, iter.indices, (int32_t[3]) { 0, 1, 2 });
-    iter.next();
-    assert_arrays_match("indices #6", "%u", 3u, iter.indices, (int32_t[3]) { 0, 0, 0 }); // Loops back
-    iter.next();
-    assert_arrays_match("indices #7", "%u", 3u, iter.indices, (int32_t[3]) { 0, 0, 1 });
-}
-
-void test_ndarray_fill_generic() {
-    // Test ndarray fill_generic
-    BEGIN_TEST();
-
-    // Choose a type that's neither int32_t nor uint64_t (candidates of SizeT) to spice it up
-    // Also make all the octets non-zero, to see if `memcpy` in `fill_generic` is working perfectly.
-    uint16_t fill_value = 0xFACE;
-
-    uint16_t in_data[6] = { 100, 101, 102, 103, 104, 105 }; // Fill `data` with values that != `999`
-    int32_t in_itemsize = sizeof(uint16_t);
-    const int32_t in_ndims = 2;
-    int32_t in_shape[in_ndims] = { 2, 3 };
-    int32_t in_strides[in_ndims] = {};
-    NDArray<int32_t> ndarray = {
-        .data = (uint8_t*) in_data,
-        .itemsize = in_itemsize,
-        .ndims = in_ndims,
-        .shape = in_shape,
-        .strides = in_strides,
-    };
-    ndarray.set_strides_by_shape();
-    ndarray.fill_generic((uint8_t*) &fill_value); // `fill_generic` here
-
-    uint16_t expected_data[6] = { fill_value, fill_value, fill_value, fill_value, fill_value, fill_value };
-    assert_arrays_match("data", "0x%hX", 6, expected_data, in_data);
-}
-
-void test_ndarray_set_to_eye() {
-    // Test `set_to_eye` behavior (helper function to implement `np.eye()`)
-    BEGIN_TEST();
-
-    double in_data[9] = { 99.0, 99.0, 99.0, 99.0, 99.0, 99.0, 99.0, 99.0, 99.0 };
-    int32_t in_itemsize = sizeof(double);
-    const int32_t in_ndims = 2;
-    int32_t in_shape[in_ndims] = { 3, 3 };
-    int32_t in_strides[in_ndims] = {};
-    NDArray<int32_t> ndarray = {
-        .data = (uint8_t*) in_data,
-        .itemsize = in_itemsize,
-        .ndims = in_ndims,
-        .shape = in_shape,
-        .strides = in_strides,
-    };
-    ndarray.set_strides_by_shape();
-
-    double zero = 0.0;
-    double one = 1.0;
-    ndarray.set_to_eye(1, (uint8_t*) &zero, (uint8_t*) &one);
-
-    assert_values_match("in_data[0]", "%f", 0.0, in_data[0]);
-    assert_values_match("in_data[1]", "%f", 1.0, in_data[1]);
-    assert_values_match("in_data[2]", "%f", 0.0, in_data[2]);
-    assert_values_match("in_data[3]", "%f", 0.0, in_data[3]);
-    assert_values_match("in_data[4]", "%f", 0.0, in_data[4]);
-    assert_values_match("in_data[5]", "%f", 1.0, in_data[5]);
-    assert_values_match("in_data[6]", "%f", 0.0, in_data[6]);
-    assert_values_match("in_data[7]", "%f", 0.0, in_data[7]);
-    assert_values_match("in_data[8]", "%f", 0.0, in_data[8]);
-}
-
-void test_slice_1() {
-    // Test `slice(5, None, None).indices(100) == slice(5, 100, 1)`
-    BEGIN_TEST();
-
-    UserSlice<int> user_slice = {
-        .start_defined = 1,
-        .start = 5,
-        .stop_defined = 0,
-        .step_defined = 0,
-    };
-
-    auto slice = user_slice.indices(100);
-    assert_values_match("start", "%d", 5, slice.start);
-    assert_values_match("stop", "%d", 100, slice.stop);
-    assert_values_match("step", "%d", 1, slice.step);
-}
-
-void test_slice_2() {
-    // Test `slice(400, 999, None).indices(100) == slice(100, 100, 1)`
-    BEGIN_TEST();
-
-    UserSlice<int> user_slice = {
-        .start_defined = 1,
-        .start = 400,
-        .stop_defined = 0,
-        .step_defined = 0,
-    };
-
-    auto slice = user_slice.indices(100);
-    assert_values_match("start", "%d", 100, slice.start);
-    assert_values_match("stop", "%d", 100, slice.stop);
-    assert_values_match("step", "%d", 1, slice.step);
-}
-
-void test_slice_3() {
-    // Test `slice(-10, -5, None).indices(100) == slice(90, 95, 1)`
-    BEGIN_TEST();
-
-    UserSlice<int> user_slice = {
-        .start_defined = 1,
-        .start = -10,
-        .stop_defined = 1,
-        .stop = -5,
-        .step_defined = 0,
-    };
-
-    auto slice = user_slice.indices(100);
-    assert_values_match("start", "%d", 90, slice.start);
-    assert_values_match("stop", "%d", 95, slice.stop);
-    assert_values_match("step", "%d", 1, slice.step);
-}
-
-void test_slice_4() {
-    // Test `slice(None, None, -5).indices(100) == (99, -1, -5)`
-    BEGIN_TEST();
-
-    UserSlice<int> user_slice = {
-        .start_defined = 0,
-        .stop_defined = 0,
-        .step_defined = 1,
-        .step = -5
-    };
-
-    auto slice = user_slice.indices(100);
-    assert_values_match("start", "%d", 99, slice.start);
-    assert_values_match("stop", "%d", -1, slice.stop);
-    assert_values_match("step", "%d", -5, slice.step);
-}
-
-void test_ndslice_1() {
-    /*
-        Reference Python code:
-        ```python
-        ndarray = np.arange(12, dtype=np.float64).reshape((3, 4));
-        # array([[ 0.,  1.,  2.,  3.],
-        #        [ 4.,  5.,  6.,  7.],
-        #        [ 8.,  9., 10., 11.]])
-
-        dst_ndarray = ndarray[-2:, 1::2]
-        # array([[ 5.,  7.],
-        #        [ 9., 11.]])
-
-        assert dst_ndarray.shape == (2, 2)
-        assert dst_ndarray.strides == (32, 16)
-        assert dst_ndarray[0, 0] == 5.0
-        assert dst_ndarray[0, 1] == 7.0
-        assert dst_ndarray[1, 0] == 9.0
-        assert dst_ndarray[1, 1] == 11.0
-        ```
-    */
-    BEGIN_TEST();
-
-    double in_data[12] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0 };
-    int32_t in_itemsize = sizeof(double);
-    const int32_t in_ndims = 2;
-    int32_t in_shape[in_ndims] = { 3, 4 };
-    int32_t in_strides[in_ndims] = {};
-    NDArray<int32_t> ndarray = {
-        .data = (uint8_t*) in_data,
-        .itemsize = in_itemsize,
-        .ndims = in_ndims,
-        .shape = in_shape,
-        .strides = in_strides
-    };
-    ndarray.set_strides_by_shape();
-
-    // Destination ndarray
-    // As documented, ndims and shape & strides must be allocated and determined by the caller.
-    const int32_t dst_ndims = 2;
-    int32_t dst_shape[dst_ndims] = {999, 999}; // Empty values
-    int32_t dst_strides[dst_ndims] = {999, 999}; // Empty values
-    NDArray<int32_t> dst_ndarray = {
-        .data = nullptr,
-        .ndims = dst_ndims,
-        .shape = dst_shape,
-        .strides = dst_strides
-    };
-
-    // Create the slice in `ndarray[-2::, 1::2]`
-    UserSlice<int32_t> user_slice_1 = {
-        .start_defined = 1,
-        .start = -2,
-        .stop_defined = 0,
-        .step_defined = 0
-    };
-
-    UserSlice<int32_t> user_slice_2 = {
-        .start_defined = 1,
-        .start = 1,
-        .stop_defined = 0,
-        .step_defined = 1,
-        .step = 2
-    };
-
-    const int32_t num_ndslices = 2;
-    NDSlice ndslices[num_ndslices] = {
-        { .type = INPUT_SLICE_TYPE_SLICE, .slice = (uint8_t*) &user_slice_1 },
-        { .type = INPUT_SLICE_TYPE_SLICE, .slice = (uint8_t*) &user_slice_2 }
-    };
-
-    ndarray.slice(num_ndslices, ndslices, &dst_ndarray);
-
-    int32_t expected_shape[dst_ndims] = { 2, 2 };
-    int32_t expected_strides[dst_ndims] = { 32, 16 };
-    assert_arrays_match("shape", "%d", dst_ndims, expected_shape, dst_ndarray.shape);
-    assert_arrays_match("strides", "%d", dst_ndims, expected_strides, dst_ndarray.strides);
-
-    assert_values_match("dst_ndarray[0, 0]", "%f", 5.0, *((double *) dst_ndarray.get_pelement((int32_t[dst_ndims]) { 0, 0 })));
-    assert_values_match("dst_ndarray[0, 1]", "%f", 7.0, *((double *) dst_ndarray.get_pelement((int32_t[dst_ndims]) { 0, 1 })));
-    assert_values_match("dst_ndarray[1, 0]", "%f", 9.0, *((double *) dst_ndarray.get_pelement((int32_t[dst_ndims]) { 1, 0 })));
-    assert_values_match("dst_ndarray[1, 1]", "%f", 11.0, *((double *) dst_ndarray.get_pelement((int32_t[dst_ndims]) { 1, 1 })));
-}
-
-void test_ndslice_2() {
-    /*
-        ```python
-        ndarray = np.arange(12, dtype=np.float64).reshape((3, 4))
-        # array([[ 0.,  1.,  2.,  3.],
-        #        [ 4.,  5.,  6.,  7.],
-        #        [ 8.,  9., 10., 11.]])
-
-        dst_ndarray = ndarray[2, ::-2]
-        # array([11.,  9.])
-
-        assert dst_ndarray.shape == (2,)
-        assert dst_ndarray.strides == (-16,)
-        assert dst_ndarray[0] == 11.0
-        assert dst_ndarray[1] == 9.0
-
-        dst_ndarray[1, 0] == 99 # If you write to `dst_ndarray`
-        assert ndarray[1, 3] == 99 # `ndarray` also updates!!
-        ```
-    */
-    BEGIN_TEST();
-
-    double in_data[12] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0 };
-    int32_t in_itemsize = sizeof(double);
-    const int32_t in_ndims = 2;
-    int32_t in_shape[in_ndims] = { 3, 4 };
-    int32_t in_strides[in_ndims] = {};
-    NDArray<int32_t> ndarray = {
-        .data = (uint8_t*) in_data,
-        .itemsize = in_itemsize,
-        .ndims = in_ndims,
-        .shape = in_shape,
-        .strides = in_strides
-    };
-    ndarray.set_strides_by_shape();
-
-    // Destination ndarray
-    // As documented, ndims and shape & strides must be allocated and determined by the caller.
-    const int32_t dst_ndims = 1;
-    int32_t dst_shape[dst_ndims] = {999}; // Empty values
-    int32_t dst_strides[dst_ndims] = {999}; // Empty values
-    NDArray<int32_t> dst_ndarray = {
-        .data = nullptr,
-        .ndims = dst_ndims,
-        .shape = dst_shape,
-        .strides = dst_strides
-    };
-
-    // Create the slice in `ndarray[2, ::-2]`
-    int32_t user_slice_1 = 2;
-    UserSlice<int32_t> user_slice_2 = {
-        .start_defined = 0,
-        .stop_defined = 0,
-        .step_defined = 1,
-        .step = -2
-    };
-
-    const int32_t num_ndslices = 2;
-    NDSlice ndslices[num_ndslices] = {
-        { .type = INPUT_SLICE_TYPE_INDEX, .slice = (uint8_t*) &user_slice_1 },
-        { .type = INPUT_SLICE_TYPE_SLICE, .slice = (uint8_t*) &user_slice_2 }
-    };
-
-    ndarray.slice(num_ndslices, ndslices, &dst_ndarray);
-
-    int32_t expected_shape[dst_ndims] = { 2 };
-    int32_t expected_strides[dst_ndims] = { -16 };
-    assert_arrays_match("shape", "%d", dst_ndims, expected_shape, dst_ndarray.shape);
-    assert_arrays_match("strides", "%d", dst_ndims, expected_strides, dst_ndarray.strides);
-
-    // [5.0, 3.0]
-    assert_values_match("dst_ndarray[0]", "%f", 11.0, *((double *) dst_ndarray.get_pelement((int32_t[dst_ndims]) { 0 })));
-    assert_values_match("dst_ndarray[1]", "%f", 9.0, *((double *) dst_ndarray.get_pelement((int32_t[dst_ndims]) { 1 })));
-}
-
-void test_can_broadcast_shape() {
-    BEGIN_TEST();
-
-    assert_values_match(
-        "can_broadcast_shape_to([3], [1, 1, 1, 1, 3]) == true",
-        "%d",
-        true,
-        ndarray_util::can_broadcast_shape_to(1, (int32_t[]) { 3 }, 5, (int32_t[]) { 1, 1, 1, 1, 3 })
-    );
-    assert_values_match(
-        "can_broadcast_shape_to([3], [3, 1]) == false",
-        "%d",
-        false,
-        ndarray_util::can_broadcast_shape_to(1, (int32_t[]) { 3 }, 2, (int32_t[]) { 3, 1 }));
-    assert_values_match(
-        "can_broadcast_shape_to([3], [3]) == true",
-        "%d",
-        true,
-        ndarray_util::can_broadcast_shape_to(1, (int32_t[]) { 3 }, 1, (int32_t[]) { 3 }));
-    assert_values_match(
-        "can_broadcast_shape_to([1], [3]) == false",
-        "%d",
-        false,
-        ndarray_util::can_broadcast_shape_to(1, (int32_t[]) { 1 }, 1, (int32_t[]) { 3 }));
-    assert_values_match(
-        "can_broadcast_shape_to([1], [1]) == true",
-        "%d",
-        true,
-        ndarray_util::can_broadcast_shape_to(1, (int32_t[]) { 1 }, 1, (int32_t[]) { 1 }));
-    assert_values_match(
-        "can_broadcast_shape_to([256, 256, 3], [256, 1, 3]) == true",
-        "%d",
-        true,
-        ndarray_util::can_broadcast_shape_to(3, (int32_t[]) { 256, 256, 3 }, 3, (int32_t[]) { 256, 1, 3 })
-    );
-    assert_values_match(
-        "can_broadcast_shape_to([256, 256, 3], [3]) == true",
-        "%d",
-        true,
-        ndarray_util::can_broadcast_shape_to(3, (int32_t[]) { 256, 256, 3 }, 1, (int32_t[]) { 3 })
-    );
-    assert_values_match(
-        "can_broadcast_shape_to([256, 256, 3], [2]) == false",
-        "%d",
-        false,
-        ndarray_util::can_broadcast_shape_to(3, (int32_t[]) { 256, 256, 3 }, 1, (int32_t[]) { 2 })
-    );
-    assert_values_match(
-        "can_broadcast_shape_to([256, 256, 3], [1]) == true",
-        "%d",
-        true,
-        ndarray_util::can_broadcast_shape_to(3, (int32_t[]) { 256, 256, 3 }, 1, (int32_t[]) { 1 })
-    );
-
-    // In cases when the shapes contain zero(es)
-    assert_values_match(
-        "can_broadcast_shape_to([0], [1]) == true",
-        "%d",
-        true,
-        ndarray_util::can_broadcast_shape_to(1, (int32_t[]) { 0 }, 1, (int32_t[]) { 1 })
-    );
-    assert_values_match(
-        "can_broadcast_shape_to([0], [2]) == false",
-        "%d",
-        false,
-        ndarray_util::can_broadcast_shape_to(1, (int32_t[]) { 0 }, 1, (int32_t[]) { 2 })
-    );
-    assert_values_match(
-        "can_broadcast_shape_to([0, 4, 0, 0], [1]) == true",
-        "%d",
-        true,
-        ndarray_util::can_broadcast_shape_to(4, (int32_t[]) { 0, 4, 0, 0 }, 1, (int32_t[]) { 1 })
-    );
-    assert_values_match(
-        "can_broadcast_shape_to([0, 4, 0, 0], [1, 1, 1, 1]) == true",
-        "%d",
-        true,
-        ndarray_util::can_broadcast_shape_to(4, (int32_t[]) { 0, 4, 0, 0 }, 4, (int32_t[]) { 1, 1, 1, 1 })
-    );
-    assert_values_match(
-        "can_broadcast_shape_to([0, 4, 0, 0], [1, 4, 1, 1]) == true",
-        "%d",
-        true,
-        ndarray_util::can_broadcast_shape_to(4, (int32_t[]) { 0, 4, 0, 0 }, 4, (int32_t[]) { 1, 4, 1, 1 })
-    );
-    assert_values_match(
-        "can_broadcast_shape_to([4, 3], [0, 3]) == false",
-        "%d",
-        false,
-        ndarray_util::can_broadcast_shape_to(2, (int32_t[]) { 4, 3 }, 2, (int32_t[]) { 0, 3 })
-    );
-    assert_values_match(
-        "can_broadcast_shape_to([4, 3], [0, 0]) == false",
-        "%d",
-        false,
-        ndarray_util::can_broadcast_shape_to(2, (int32_t[]) { 4, 3 }, 2, (int32_t[]) { 0, 0 })
-    );
-}
-
-void test_ndarray_broadcast_1() {
-    /*
-    # array = np.array([[19.9, 29.9, 39.9, 49.9]], dtype=np.float64)
-    # >>> [[19.9 29.9 39.9 49.9]]
-    #
-    # array = np.broadcast_to(array, (2, 3, 4))
-    # >>> [[[19.9 29.9 39.9 49.9]
-    # >>>   [19.9 29.9 39.9 49.9]
-    # >>>   [19.9 29.9 39.9 49.9]]
-    # >>>  [[19.9 29.9 39.9 49.9]
-    # >>>   [19.9 29.9 39.9 49.9]
-    # >>>   [19.9 29.9 39.9 49.9]]]
-    #
-    # assery array.strides == (0, 0, 8)
-
-    */
-    BEGIN_TEST();
-
-    double in_data[4] = { 19.9, 29.9, 39.9, 49.9 };
-    const int32_t in_ndims = 2;
-    int32_t in_shape[in_ndims] = {1, 4};
-    int32_t in_strides[in_ndims] = {};
-    NDArray<int32_t> ndarray = {
-        .data = (uint8_t*) in_data,
-        .itemsize = sizeof(double),
-        .ndims = in_ndims,
-        .shape = in_shape,
-        .strides = in_strides
-    };
-    ndarray.set_strides_by_shape();
-
-    const int32_t dst_ndims = 3;
-    int32_t dst_shape[dst_ndims] = {2, 3, 4};
-    int32_t dst_strides[dst_ndims] = {};
-    NDArray<int32_t> dst_ndarray = {
-        .ndims = dst_ndims,
-        .shape = dst_shape,
-        .strides = dst_strides
-    };
-
-    ndarray.broadcast_to(&dst_ndarray);
-
-    assert_arrays_match("dst_ndarray->strides", "%d", dst_ndims, (int32_t[]) { 0, 0, 8 }, dst_ndarray.strides);
-
-    assert_values_match("dst_ndarray[0, 0, 0]", "%f", 19.9, *((double*) dst_ndarray.get_pelement((int32_t[]) {0, 0, 0})));
-    assert_values_match("dst_ndarray[0, 0, 1]", "%f", 29.9, *((double*) dst_ndarray.get_pelement((int32_t[]) {0, 0, 1})));
-    assert_values_match("dst_ndarray[0, 0, 2]", "%f", 39.9, *((double*) dst_ndarray.get_pelement((int32_t[]) {0, 0, 2})));
-    assert_values_match("dst_ndarray[0, 0, 3]", "%f", 49.9, *((double*) dst_ndarray.get_pelement((int32_t[]) {0, 0, 3})));
-    assert_values_match("dst_ndarray[0, 1, 0]", "%f", 19.9, *((double*) dst_ndarray.get_pelement((int32_t[]) {0, 1, 0})));
-    assert_values_match("dst_ndarray[0, 1, 1]", "%f", 29.9, *((double*) dst_ndarray.get_pelement((int32_t[]) {0, 1, 1})));
-    assert_values_match("dst_ndarray[0, 1, 2]", "%f", 39.9, *((double*) dst_ndarray.get_pelement((int32_t[]) {0, 1, 2})));
-    assert_values_match("dst_ndarray[0, 1, 3]", "%f", 49.9, *((double*) dst_ndarray.get_pelement((int32_t[]) {0, 1, 3})));
-    assert_values_match("dst_ndarray[1, 2, 3]", "%f", 49.9, *((double*) dst_ndarray.get_pelement((int32_t[]) {1, 2, 3})));
-}
-
-void test_assign_with() {
-    /*
-        ```
-        xs = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]], dtype=np.float64)
-        ys = xs.shape
-        ```
-    */
-}
-
-int main() {
-    test_calc_size_from_shape_normal();
-    test_calc_size_from_shape_has_zero();
-    test_set_strides_by_shape();
-    test_ndarray_indices_iter_normal();
-    test_ndarray_fill_generic();
-    test_ndarray_set_to_eye();
-    test_slice_1();
-    test_slice_2();
-    test_slice_3();
-    test_slice_4();
-    test_ndslice_1();
-    test_ndslice_2();
-    test_can_broadcast_shape();
-    test_ndarray_broadcast_1();
-    test_assign_with();
-    return 0;
-}
--- a/nac3core/irrt/irrt_typedefs.hpp
+++ b/nac3core/irrt/irrt_typedefs.hpp
@ -1,14 +0,0 @@
-#pragma once
-
-// This is made toggleable since `irrt_test.cpp` itself would include
-// headers that define the `int_t` family.
-#ifndef IRRT_DONT_TYPEDEF_INTS
-typedef _BitInt(8) int8_t;
-typedef unsigned _BitInt(8) uint8_t;
-typedef _BitInt(32) int32_t;
-typedef unsigned _BitInt(32) uint32_t;
-typedef _BitInt(64) int64_t;
-typedef unsigned _BitInt(64) uint64_t;
-#endif
-
-typedef int32_t SliceIndex;
--- a/nac3core/irrt/irrt_utils.hpp
+++ b/nac3core/irrt/irrt_utils.hpp
@ -1,37 +0,0 @@
-#pragma once
-
-#include "irrt_typedefs.hpp"
-
-namespace {
-    template <typename T>
-    T max(T a, T b) {
-        return a > b ? a : b;
-    }
-
-    template <typename T>
-    T min(T a, T b) {
-        return a > b ? b : a;
-    }
-
-    template <typename T>
-    bool arrays_match(int len, T *as, T *bs) {
-        for (int i = 0; i < len; i++) {
-            if (as[i] != bs[i]) return false;
-        }
-        return true;
-    }
-
-    void irrt_panic() {
-        // Crash the program for now.
-        // TODO: Don't crash the program
-        //       ... or at least produce a good message when doing testing IRRT
-            
-        uint8_t* death = nullptr;
-        *death = 0; // TODO: address 0 on hardware might be writable?
-    }
-
-    // TODO: Make this a macro and allow it to be toggled on/off (e.g., debug vs release)
-    void irrt_assert(bool condition) {
-        if (!condition) irrt_panic();
-    }
-}
--- a/nac3core/src/codegen/builtin_fns.rs
+++ b/nac3core/src/codegen/builtin_fns.rs
--- a/nac3core/src/codegen/classes.rs
+++ b/nac3core/src/codegen/classes.rs
@ -1,16 +1,16 @@
-use crate::codegen::{
-    llvm_intrinsics::call_int_umin, stmt::gen_for_callback_incrementing, CodeGenContext,
-    CodeGenerator,
-};
-use inkwell::context::Context;
-use inkwell::types::{ArrayType, BasicType, StructType};
-use inkwell::values::{ArrayValue, BasicValue, StructValue};
 use inkwell::{
-    types::{AnyTypeEnum, BasicTypeEnum, IntType, PointerType},
-    values::{BasicValueEnum, IntValue, PointerValue},
+    context::Context,
+    types::{AnyTypeEnum, ArrayType, BasicType, BasicTypeEnum, IntType, PointerType, StructType},
+    values::{ArrayValue, BasicValue, BasicValueEnum, IntValue, PointerValue, StructValue},
    AddressSpace, IntPredicate,
 };
-use itertools::Itertools;
+
+use super::{
+    irrt::{call_ndarray_calc_size, call_ndarray_flatten_index},
+    llvm_intrinsics::call_int_umin,
+    stmt::gen_for_callback_incrementing,
+    CodeGenContext, CodeGenerator,
+};

 /// A LLVM type that is used to represent a non-primitive type in NAC3.
 pub trait ProxyType<'ctx>: Into<Self::Base> {
@ -1249,11 +1249,13 @@ impl<'ctx> NDArrayType<'ctx> {

    /// Returns the element type of this `ndarray` type.
    #[must_use]
-    pub fn element_type(&self) -> BasicTypeEnum<'ctx> {
+    pub fn element_type(&self) -> AnyTypeEnum<'ctx> {
        self.as_base_type()
            .get_element_type()
            .into_struct_type()
            .get_field_type_at_index(2)
+            .map(BasicTypeEnum::into_pointer_type)
+            .map(PointerType::get_element_type)
            .unwrap()
    }
 }
@ -1403,7 +1405,7 @@ impl<'ctx> NDArrayValue<'ctx> {

    /// Returns the double-indirection pointer to the `data` array, as if by calling `getelementptr`
    /// on the field.
-    fn ptr_to_data(&self, ctx: &CodeGenContext<'ctx, '_>) -> PointerValue<'ctx> {
+    pub fn ptr_to_data(&self, ctx: &CodeGenContext<'ctx, '_>) -> PointerValue<'ctx> {
        let llvm_i32 = ctx.ctx.i32_type();
        let var_name = self.name.map(|v| format!("{v}.data.addr")).unwrap_or_default();

@ -1600,8 +1602,7 @@ impl<'ctx> ArrayLikeValue<'ctx> for NDArrayDataProxy<'ctx, '_> {
        ctx: &CodeGenContext<'ctx, '_>,
        generator: &G,
    ) -> IntValue<'ctx> {
-        todo!()
-        // call_ndarray_calc_size(generator, ctx, &self.as_slice_value(ctx, generator), (None, None))
+        call_ndarray_calc_size(generator, ctx, &self.as_slice_value(ctx, generator), (None, None))
    }
 }

@ -1675,19 +1676,17 @@ impl<'ctx, Index: UntypedArrayLikeAccessor<'ctx>> ArrayLikeIndexer<'ctx, Index>
            indices_elem_ty.get_bit_width()
        );

-        todo!()
+        let index = call_ndarray_flatten_index(generator, ctx, *self.0, indices);

-        // let index = call_ndarray_flatten_index(generator, ctx, *self.0, indices);
-
-        // unsafe {
-        //     ctx.builder
-        //         .build_in_bounds_gep(
-        //             self.base_ptr(ctx, generator),
-        //             &[index],
-        //             name.unwrap_or_default(),
-        //         )
-        //         .unwrap()
-        // }
+        unsafe {
+            ctx.builder
+                .build_in_bounds_gep(
+                    self.base_ptr(ctx, generator),
+                    &[index],
+                    name.unwrap_or_default(),
+                )
+                .unwrap()
+        }
    }

    fn ptr_offset<G: CodeGenerator + ?Sized>(
@ -1719,6 +1718,7 @@ impl<'ctx, Index: UntypedArrayLikeAccessor<'ctx>> ArrayLikeIndexer<'ctx, Index>
        gen_for_callback_incrementing(
            generator,
            ctx,
+            None,
            llvm_usize.const_zero(),
            (len, false),
            |generator, ctx, _, i| {
@ -1763,307 +1763,3 @@ impl<'ctx, Index: UntypedArrayLikeAccessor<'ctx>> UntypedArrayLikeMutator<'ctx,
    for NDArrayDataProxy<'ctx, '_>
 {
 }
-
-#[derive(Debug, Clone, Copy)]
-pub struct StructField<'ctx> {
-    /// The GEP index of this struct field.
-    pub gep_index: u32,
-    /// Name of this struct field.
-    ///
-    /// Used for generating names.
-    pub name: &'static str,
-    /// The type of this struct field.
-    pub ty: BasicTypeEnum<'ctx>,
-}
-
-pub struct StructFields<'ctx> {
-    /// Name of the struct.
-    ///
-    /// Used for generating names.
-    pub name: &'static str,
-
-    /// All the [`StructField`]s of this struct.
-    ///
-    /// **NOTE:** The index position of a [`StructField`]
-    /// matches the element's [`StructField::index`].
-    pub fields: Vec<StructField<'ctx>>,
-}
-
-struct StructFieldsBuilder<'ctx> {
-    gep_index_counter: u32,
-    /// Name of the struct to be built.
-    name: &'static str,
-    fields: Vec<StructField<'ctx>>,
-}
-
-impl<'ctx> StructField<'ctx> {
-    pub fn gep(
-        &self,
-        ctx: &CodeGenContext<'ctx, '_>,
-        ptr: PointerValue<'ctx>,
-    ) -> PointerValue<'ctx> {
-        ctx.builder.build_struct_gep(ptr, self.gep_index, self.name).unwrap()
-    }
-
-    pub fn load(
-        &self,
-        ctx: &CodeGenContext<'ctx, '_>,
-        ptr: PointerValue<'ctx>,
-    ) -> BasicValueEnum<'ctx> {
-        ctx.builder.build_load(self.gep(ctx, ptr), self.name).unwrap()
-    }
-
-    pub fn store<V>(&self, ctx: &CodeGenContext<'ctx, '_>, ptr: PointerValue<'ctx>, value: V)
-    where
-        V: BasicValue<'ctx>,
-    {
-        ctx.builder.build_store(ptr, value).unwrap();
-    }
-}
-
-type IsInstanceError = String;
-type IsInstanceResult = Result<(), IsInstanceError>;
-
-pub fn check_basic_types_match<'ctx, A, B>(expected: A, got: B) -> IsInstanceResult
-where
-    A: BasicType<'ctx>,
-    B: BasicType<'ctx>,
-{
-    let expected = expected.as_basic_type_enum();
-    let got = got.as_basic_type_enum();
-
-    // Put those logic into here,
-    // otherwise there is always a fallback reporting on any kind of mismatch
-    match (expected, got) {
-        (BasicTypeEnum::IntType(expected), BasicTypeEnum::IntType(got)) => {
-            if expected.get_bit_width() != got.get_bit_width() {
-                return Err(format!(
-                    "Expected IntType ({expected}-bit(s)), got IntType ({got}-bit(s))"
-                ));
-            }
-        }
-        (expected, got) => {
-            if expected != got {
-                return Err(format!("Expected {expected}, got {got}"));
-            }
-        }
-    }
-    Ok(())
-}
-
-impl<'ctx> StructFields<'ctx> {
-    pub fn num_fields(&self) -> u32 {
-        self.fields.len() as u32
-    }
-
-    pub fn as_struct_type(&self, ctx: &'ctx Context) -> StructType<'ctx> {
-        let llvm_fields = self.fields.iter().map(|field| field.ty).collect_vec();
-        ctx.struct_type(llvm_fields.as_slice(), false)
-    }
-
-    pub fn is_type(&self, scrutinee: StructType<'ctx>) -> IsInstanceResult {
-        // Check scrutinee's number of struct fields
-        if scrutinee.count_fields() != self.num_fields() {
-            return Err(format!(
-                "Expected {expected_count} field(s) in `{struct_name}` type, got {got_count}",
-                struct_name = self.name,
-                expected_count = self.num_fields(),
-                got_count = scrutinee.count_fields(),
-            ));
-        }
-
-        // Check the scrutinee's field types
-        for field in self.fields.iter() {
-            let expected_field_ty = field.ty;
-            let got_field_ty = scrutinee.get_field_type_at_index(field.gep_index).unwrap();
-
-            if let Err(field_err) = check_basic_types_match(expected_field_ty, got_field_ty) {
-                return Err(format!(
-                    "Field GEP index {gep_index} does not match the expected type of ({struct_name}::{field_name}): {field_err}",
-                    gep_index = field.gep_index,
-                    struct_name = self.name,
-                    field_name = field.name,
-                ));
-            }
-        }
-
-        // Done
-        Ok(())
-    }
-}
-
-impl<'ctx> StructFieldsBuilder<'ctx> {
-    fn start(name: &'static str) -> Self {
-        StructFieldsBuilder { gep_index_counter: 0, name, fields: Vec::new() }
-    }
-
-    fn add_field(&mut self, name: &'static str, ty: BasicTypeEnum<'ctx>) -> StructField<'ctx> {
-        let index = self.gep_index_counter;
-        self.gep_index_counter += 1;
-        StructField { gep_index: index, name, ty }
-    }
-
-    fn end(self) -> StructFields<'ctx> {
-        StructFields { name: self.name, fields: self.fields }
-    }
-}
-
-#[derive(Debug, Clone, Copy)]
-pub struct NpArrayType<'ctx> {
-    pub size_type: IntType<'ctx>,
-    pub elem_type: BasicTypeEnum<'ctx>,
-}
-
-pub struct NpArrayStructFields<'ctx> {
-    pub whole_struct: StructFields<'ctx>,
-    pub data: StructField<'ctx>,
-    pub itemsize: StructField<'ctx>,
-    pub ndims: StructField<'ctx>,
-    pub shape: StructField<'ctx>,
-    pub strides: StructField<'ctx>,
-}
-
-impl<'ctx> NpArrayType<'ctx> {
-    pub fn new_opaque_elem(
-        ctx: &CodeGenContext<'ctx, '_>,
-        size_type: IntType<'ctx>,
-    ) -> NpArrayType<'ctx> {
-        NpArrayType { size_type, elem_type: ctx.ctx.i8_type().as_basic_type_enum() }
-    }
-
-    pub fn struct_type(&self, ctx: &CodeGenContext<'ctx, '_>) -> StructType<'ctx> {
-        self.fields().whole_struct.as_struct_type(ctx.ctx)
-    }
-
-    pub fn fields(&self) -> NpArrayStructFields<'ctx> {
-        let mut builder = StructFieldsBuilder::start("NpArray");
-
-        let addrspace = AddressSpace::default();
-
-        let byte_type = self.size_type.get_context().i8_type();
-
-        // Make sure the struct matches PERFECTLY with that defined in `nac3core/irrt`.
-        let data = builder.add_field("data", byte_type.ptr_type(addrspace).into());
-        let itemsize = builder.add_field("itemsize", self.size_type.into());
-        let ndims = builder.add_field("ndims", self.size_type.into());
-        let shape = builder.add_field("shape", self.size_type.ptr_type(addrspace).into());
-        let strides = builder.add_field("strides", self.size_type.ptr_type(addrspace).into());
-
-        NpArrayStructFields { whole_struct: builder.end(), data, itemsize, ndims, shape, strides }
-    }
-
-    /// Allocate an `ndarray` on stack, with the following notes:
-    ///
-    /// - `ndarray.ndims` will be initialized to `in_ndims`.
-    /// - `ndarray.itemsize` will be initialized to the size of `self.elem_type.size_of()`.
-    /// - `ndarray.shape` and `ndarray.strides` will be allocated on the stack with number of elements being `in_ndims`,
-    /// all with empty/uninitialized values.
-    pub fn alloca(
-        &self,
-        ctx: &CodeGenContext<'ctx, '_>,
-        in_ndims: IntValue<'ctx>,
-        name: &str,
-    ) -> NpArrayValue<'ctx> {
-        let fields = self.fields();
-        let ptr =
-            ctx.builder.build_alloca(fields.whole_struct.as_struct_type(ctx.ctx), name).unwrap();
-
-        // Allocate `in_dims` number of `size_type` on the stack for `shape` and `strides`
-        let allocated_shape =
-            ctx.builder.build_array_alloca(fields.shape.ty, in_ndims, "allocated_shape").unwrap();
-        let allocated_strides = ctx
-            .builder
-            .build_array_alloca(fields.strides.ty, in_ndims, "allocated_strides")
-            .unwrap();
-
-        let value = NpArrayValue { ty: *self, ptr };
-        value.store_ndims(ctx, in_ndims);
-        value.store_itemsize(ctx, self.elem_type.size_of().unwrap());
-        value.store_shape(ctx, allocated_shape);
-        value.store_strides(ctx, allocated_strides);
-
-        return value;
-    }
-}
-
-#[derive(Debug, Clone, Copy)]
-pub struct NpArrayValue<'ctx> {
-    pub ty: NpArrayType<'ctx>,
-    pub ptr: PointerValue<'ctx>,
-}
-
-impl<'ctx> NpArrayValue<'ctx> {
-    pub fn load_ndims(&self, ctx: &CodeGenContext<'ctx, '_>) -> IntValue<'ctx> {
-        let field = self.ty.fields().ndims;
-        field.load(ctx, self.ptr).into_int_value()
-    }
-
-    pub fn store_ndims(&self, ctx: &CodeGenContext<'ctx, '_>, value: IntValue<'ctx>) {
-        let field = self.ty.fields().ndims;
-        field.store(ctx, self.ptr, value);
-    }
-
-    pub fn load_itemsize(&self, ctx: &CodeGenContext<'ctx, '_>) -> IntValue<'ctx> {
-        let field = self.ty.fields().itemsize;
-        field.load(ctx, self.ptr).into_int_value()
-    }
-
-    pub fn store_itemsize(&self, ctx: &CodeGenContext<'ctx, '_>, value: IntValue<'ctx>) {
-        let field = self.ty.fields().itemsize;
-        field.store(ctx, self.ptr, value);
-    }
-
-    pub fn load_shape(&self, ctx: &CodeGenContext<'ctx, '_>) -> PointerValue<'ctx> {
-        let field = self.ty.fields().shape;
-        field.load(ctx, self.ptr).into_pointer_value()
-    }
-
-    pub fn store_shape(&self, ctx: &CodeGenContext<'ctx, '_>, value: PointerValue<'ctx>) {
-        let field = self.ty.fields().shape;
-        field.store(ctx, self.ptr, value);
-    }
-
-    pub fn load_strides(&self, ctx: &CodeGenContext<'ctx, '_>) -> PointerValue<'ctx> {
-        let field = self.ty.fields().strides;
-        field.load(ctx, self.ptr).into_pointer_value()
-    }
-
-    pub fn store_strides(&self, ctx: &CodeGenContext<'ctx, '_>, value: PointerValue<'ctx>) {
-        let field = self.ty.fields().strides;
-        field.store(ctx, self.ptr, value);
-    }
-
-    /// TODO: DOCUMENT ME -- NDIMS WOULD NEVER CHANGE!!!!!
-    pub fn shape_slice(
-        &self,
-        ctx: &CodeGenContext<'ctx, '_>,
-    ) -> TypedArrayLikeAdapter<'ctx, IntValue<'ctx>> {
-        let field = self.ty.fields().shape;
-        field.gep(ctx, self.ptr);
-
-        let ndims = self.load_ndims(ctx);
-
-        TypedArrayLikeAdapter {
-            adapted: ArraySliceValue(self.ptr, ndims, Some(field.name)),
-            downcast_fn: Box::new(|_ctx, x| x.into_int_value()),
-            upcast_fn: Box::new(|_ctx, x| x.as_basic_value_enum()),
-        }
-    }
-
-    /// TODO: DOCUMENT ME -- NDIMS WOULD NEVER CHANGE!!!!!
-    pub fn strides_slice(
-        &self,
-        ctx: &CodeGenContext<'ctx, '_>,
-    ) -> TypedArrayLikeAdapter<'ctx, IntValue<'ctx>> {
-        let field = self.ty.fields().strides;
-        field.gep(ctx, self.ptr);
-
-        let ndims = self.load_ndims(ctx);
-
-        TypedArrayLikeAdapter {
-            adapted: ArraySliceValue(self.ptr, ndims, Some(field.name)),
-            downcast_fn: Box::new(|_ctx, x| x.into_int_value()),
-            upcast_fn: Box::new(|_ctx, x| x.as_basic_value_enum()),
-        }
-    }
-}
--- a/nac3core/src/codegen/concrete_type.rs
+++ b/nac3core/src/codegen/concrete_type.rs
@ -1,3 +1,9 @@
+use std::collections::HashMap;
+
+use indexmap::IndexMap;
+
+use nac3parser::ast::StrRef;
+
 use crate::{
    symbol_resolver::SymbolValue,
    toplevel::DefinitionId,
@ -9,10 +15,6 @@ use crate::{
    },
 };

-use indexmap::IndexMap;
-use nac3parser::ast::StrRef;
-use std::collections::HashMap;
-
 pub struct ConcreteTypeStore {
    store: Vec<ConcreteTypeEnum>,
 }
@ -25,6 +27,7 @@ pub struct ConcreteFuncArg {
    pub name: StrRef,
    pub ty: ConcreteType,
    pub default_value: Option<SymbolValue>,
+    pub is_vararg: bool,
 }

 #[derive(Clone, Debug)]
@ -46,6 +49,7 @@ pub enum ConcreteTypeEnum {
    TPrimitive(Primitive),
    TTuple {
        ty: Vec<ConcreteType>,
+        is_vararg_ctx: bool,
    },
    TObj {
        obj_id: DefinitionId,
@ -102,8 +106,16 @@ impl ConcreteTypeStore {
                .iter()
                .map(|arg| ConcreteFuncArg {
                    name: arg.name,
-                    ty: self.from_unifier_type(unifier, primitives, arg.ty, cache),
+                    ty: if arg.is_vararg {
+                        let tuple_ty = unifier
+                            .add_ty(TypeEnum::TTuple { ty: vec![arg.ty], is_vararg_ctx: true });
+
+                        self.from_unifier_type(unifier, primitives, tuple_ty, cache)
+                    } else {
+                        self.from_unifier_type(unifier, primitives, arg.ty, cache)
+                    },
                    default_value: arg.default_value.clone(),
+                    is_vararg: arg.is_vararg,
                })
                .collect(),
            ret: self.from_unifier_type(unifier, primitives, signature.ret, cache),
@ -158,11 +170,12 @@ impl ConcreteTypeStore {
            cache.insert(ty, None);
            let ty_enum = unifier.get_ty(ty);
            let result = match &*ty_enum {
-                TypeEnum::TTuple { ty } => ConcreteTypeEnum::TTuple {
+                TypeEnum::TTuple { ty, is_vararg_ctx } => ConcreteTypeEnum::TTuple {
                    ty: ty
                        .iter()
                        .map(|t| self.from_unifier_type(unifier, primitives, *t, cache))
                        .collect(),
+                    is_vararg_ctx: *is_vararg_ctx,
                },
                TypeEnum::TObj { obj_id, fields, params } => ConcreteTypeEnum::TObj {
                    obj_id: *obj_id,
@ -248,11 +261,12 @@ impl ConcreteTypeStore {
                *cache.get_mut(&cty).unwrap() = Some(ty);
                return ty;
            }
-            ConcreteTypeEnum::TTuple { ty } => TypeEnum::TTuple {
+            ConcreteTypeEnum::TTuple { ty, is_vararg_ctx } => TypeEnum::TTuple {
                ty: ty
                    .iter()
                    .map(|cty| self.to_unifier_type(unifier, primitives, *cty, cache))
                    .collect(),
+                is_vararg_ctx: *is_vararg_ctx,
            },
            ConcreteTypeEnum::TVirtual { ty } => {
                TypeEnum::TVirtual { ty: self.to_unifier_type(unifier, primitives, *ty, cache) }
@ -277,6 +291,7 @@ impl ConcreteTypeStore {
                        name: arg.name,
                        ty: self.to_unifier_type(unifier, primitives, arg.ty, cache),
                        default_value: arg.default_value.clone(),
+                        is_vararg: false,
                    })
                    .collect(),
                ret: self.to_unifier_type(unifier, primitives, *ret, cache),
--- a/nac3core/src/codegen/expr.rs
+++ b/nac3core/src/codegen/expr.rs
--- a/nac3core/src/codegen/extern_fns.rs
+++ b/nac3core/src/codegen/extern_fns.rs
@ -1,8 +1,10 @@
-use inkwell::attributes::{Attribute, AttributeLoc};
-use inkwell::values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue};
+use inkwell::{
+    attributes::{Attribute, AttributeLoc},
+    values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue},
+};
 use itertools::Either;

-use crate::codegen::CodeGenContext;
+use super::CodeGenContext;

 /// Macro to generate extern function
 /// Both function return type and function parameter type are `FloatValue`
@ -13,8 +15,8 @@ use crate::codegen::CodeGenContext;
 /// * `$extern_fn:literal`: Name of underlying extern function
 ///
 /// Optional Arguments:
-/// * `$(,$attributes:literal)*)`: Attributes linked with the extern function
-/// The default attributes are "mustprogress", "nofree", "nounwind", "willreturn", and "writeonly"
+/// * `$(,$attributes:literal)*)`: Attributes linked with the extern function.
+///   The default attributes are "mustprogress", "nofree", "nounwind", "willreturn", and "writeonly".
 ///   These will be used unless other attributes are specified
 /// * `$(,$args:ident)*`: Operands of the extern function
 ///   The data type of these operands will be set to `FloatValue`
@ -130,3 +132,62 @@ pub fn call_ldexp<'ctx>(
        .map(Either::unwrap_left)
        .unwrap()
 }
+
+/// Macro to generate `np_linalg` and `sp_linalg` functions
+/// The function takes as input `NDArray` and returns ()
+///
+/// Arguments:
+/// * `$fn_name:ident`: The identifier of the rust function to be generated
+/// * `$extern_fn:literal`: Name of underlying extern function
+/// * (2/3/4): Number of `NDArray` that function takes as input
+///
+/// Note:
+/// The operands and resulting `NDArray` are both passed as input to the funcion
+/// It is the responsibility of caller to ensure that output `NDArray` is properly allocated on stack
+/// The function changes the content of the output `NDArray` in-place
+macro_rules! generate_linalg_extern_fn {
+    ($fn_name:ident, $extern_fn:literal, 2) => {
+        generate_linalg_extern_fn!($fn_name, $extern_fn, mat1, mat2);
+    };
+    ($fn_name:ident, $extern_fn:literal, 3) => {
+        generate_linalg_extern_fn!($fn_name, $extern_fn, mat1, mat2, mat3);
+    };
+    ($fn_name:ident, $extern_fn:literal, 4) => {
+        generate_linalg_extern_fn!($fn_name, $extern_fn, mat1, mat2, mat3, mat4);
+    };
+    ($fn_name:ident, $extern_fn:literal $(,$input_matrix:ident)*) => {
+        #[doc = concat!("Invokes the linalg `", stringify!($extern_fn), " function." )]
+        pub fn $fn_name<'ctx>(
+            ctx: &mut CodeGenContext<'ctx, '_>
+            $(,$input_matrix: BasicValueEnum<'ctx>)*,
+            name: Option<&str>,
+        ){
+            const FN_NAME: &str = $extern_fn;
+            let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+                let fn_type = ctx.ctx.void_type().fn_type(&[$($input_matrix.get_type().into()),*], false);
+
+                let func = ctx.module.add_function(FN_NAME, fn_type, None);
+                for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
+                    func.add_attribute(
+                        AttributeLoc::Function,
+                        ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
+                    );
+                }
+                func
+            });
+
+            ctx.builder.build_call(extern_fn, &[$($input_matrix.into(),)*], name.unwrap_or_default()).unwrap();
+        }
+    };
+}
+
+generate_linalg_extern_fn!(call_np_linalg_cholesky, "np_linalg_cholesky", 2);
+generate_linalg_extern_fn!(call_np_linalg_qr, "np_linalg_qr", 3);
+generate_linalg_extern_fn!(call_np_linalg_svd, "np_linalg_svd", 4);
+generate_linalg_extern_fn!(call_np_linalg_inv, "np_linalg_inv", 2);
+generate_linalg_extern_fn!(call_np_linalg_pinv, "np_linalg_pinv", 2);
+generate_linalg_extern_fn!(call_np_linalg_matrix_power, "np_linalg_matrix_power", 3);
+generate_linalg_extern_fn!(call_np_linalg_det, "np_linalg_det", 2);
+generate_linalg_extern_fn!(call_sp_linalg_lu, "sp_linalg_lu", 3);
+generate_linalg_extern_fn!(call_sp_linalg_schur, "sp_linalg_schur", 3);
+generate_linalg_extern_fn!(call_sp_linalg_hessenberg, "sp_linalg_hessenberg", 3);
--- a/nac3core/src/codegen/generator.rs
+++ b/nac3core/src/codegen/generator.rs
@ -1,16 +1,18 @@
-use crate::{
-    codegen::{bool_to_i1, bool_to_i8, classes::ArraySliceValue, expr::*, stmt::*, CodeGenContext},
-    symbol_resolver::ValueEnum,
-    toplevel::{DefinitionId, TopLevelDef},
-    typecheck::typedef::{FunSignature, Type},
-};
 use inkwell::{
    context::Context,
    types::{BasicTypeEnum, IntType},
    values::{BasicValueEnum, IntValue, PointerValue},
 };
+
 use nac3parser::ast::{Expr, Stmt, StrRef};

+use super::{bool_to_i1, bool_to_i8, classes::ArraySliceValue, expr::*, stmt::*, CodeGenContext};
+use crate::{
+    symbol_resolver::ValueEnum,
+    toplevel::{DefinitionId, TopLevelDef},
+    typecheck::typedef::{FunSignature, Type},
+};
+
 pub trait CodeGenerator {
    /// Return the module name for the code generator.
    fn get_name(&self) -> &str;
@ -57,6 +59,7 @@ pub trait CodeGenerator {
    /// - fun: Function signature, definition ID and the substitution key.
    /// - params: Function parameters. Note that this does not include the object even if the
    ///   function is a class method.
+    ///
    /// Note that this function should check if the function is generated in another thread (due to
    /// possible race condition), see the default implementation for an example.
    fn gen_func_instance<'ctx>(
@ -123,11 +126,45 @@ pub trait CodeGenerator {
        ctx: &mut CodeGenContext<'ctx, '_>,
        target: &Expr<Option<Type>>,
        value: ValueEnum<'ctx>,
+        value_ty: Type,
    ) -> Result<(), String>
    where
        Self: Sized,
    {
-        gen_assign(self, ctx, target, value)
+        gen_assign(self, ctx, target, value, value_ty)
+    }
+
+    /// Generate code for an assignment expression where LHS is a `"target_list"`.
+    ///
+    /// See <https://docs.python.org/3/reference/simple_stmts.html#assignment-statements>.
+    fn gen_assign_target_list<'ctx>(
+        &mut self,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        targets: &Vec<Expr<Option<Type>>>,
+        value: ValueEnum<'ctx>,
+        value_ty: Type,
+    ) -> Result<(), String>
+    where
+        Self: Sized,
+    {
+        gen_assign_target_list(self, ctx, targets, value, value_ty)
+    }
+
+    /// Generate code for an item assignment.
+    ///
+    /// i.e., `target[key] = value`
+    fn gen_setitem<'ctx>(
+        &mut self,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        target: &Expr<Option<Type>>,
+        key: &Expr<Option<Type>>,
+        value: ValueEnum<'ctx>,
+        value_ty: Type,
+    ) -> Result<(), String>
+    where
+        Self: Sized,
+    {
+        gen_setitem(self, ctx, target, key, value, value_ty)
    }

    /// Generate code for a while expression.
--- a/nac3core/src/codegen/irrt/mod.rs
+++ b/nac3core/src/codegen/irrt/mod.rs
@ -1,30 +1,30 @@
-use crate::{typecheck::typedef::Type, util::SizeVariant};
-
-mod test;
-
-use super::{
-    classes::{
-        ArrayLikeIndexer, ArrayLikeValue, ArraySliceValue, ListValue, NDArrayValue, NpArrayType,
-        NpArrayValue, TypedArrayLikeAdapter, UntypedArrayLikeAccessor,
-    },
-    llvm_intrinsics, CodeGenContext, CodeGenerator,
-};
-use crate::codegen::classes::TypedArrayLikeAccessor;
-use crate::codegen::stmt::gen_for_callback_incrementing;
 use inkwell::{
    attributes::{Attribute, AttributeLoc},
    context::Context,
    memory_buffer::MemoryBuffer,
    module::Module,
-    types::{BasicType, BasicTypeEnum, FunctionType, IntType, PointerType},
-    values::{BasicValueEnum, CallSiteValue, FloatValue, FunctionValue, IntValue},
+    types::{BasicTypeEnum, IntType},
+    values::{BasicValue, BasicValueEnum, CallSiteValue, FloatValue, IntValue},
    AddressSpace, IntPredicate,
 };
 use itertools::Either;
+
 use nac3parser::ast::Expr;

+use super::{
+    classes::{
+        ArrayLikeIndexer, ArrayLikeValue, ArraySliceValue, ListValue, NDArrayValue,
+        TypedArrayLikeAccessor, TypedArrayLikeAdapter, UntypedArrayLikeAccessor,
+    },
+    llvm_intrinsics,
+    macros::codegen_unreachable,
+    stmt::gen_for_callback_incrementing,
+    CodeGenContext, CodeGenerator,
+};
+use crate::{symbol_resolver::SymbolResolver, typecheck::typedef::Type};
+
 #[must_use]
-pub fn load_irrt(ctx: &Context) -> Module {
+pub fn load_irrt<'ctx>(ctx: &'ctx Context, symbol_resolver: &dyn SymbolResolver) -> Module<'ctx> {
    let bitcode_buf = MemoryBuffer::create_from_memory_range(
        include_bytes!(concat!(env!("OUT_DIR"), "/irrt.bc")),
        "irrt_bitcode_buffer",
@ -40,6 +40,25 @@ pub fn load_irrt(ctx: &Context) -> Module {
        let function = irrt_mod.get_function(symbol).unwrap();
        function.add_attribute(AttributeLoc::Function, ctx.create_enum_attribute(inline_attr, 0));
    }
+
+    // Initialize all global `EXN_*` exception IDs in IRRT with the [`SymbolResolver`].
+    let exn_id_type = ctx.i32_type();
+    let errors = &[
+        ("EXN_INDEX_ERROR", "0:IndexError"),
+        ("EXN_VALUE_ERROR", "0:ValueError"),
+        ("EXN_ASSERTION_ERROR", "0:AssertionError"),
+        ("EXN_TYPE_ERROR", "0:TypeError"),
+    ];
+    for (irrt_name, symbol_name) in errors {
+        let exn_id = symbol_resolver.get_string_id(symbol_name);
+        let exn_id = exn_id_type.const_int(exn_id as u64, false).as_basic_value_enum();
+
+        let global = irrt_mod.get_global(irrt_name).unwrap_or_else(|| {
+            panic!("Exception symbol name '{irrt_name}' should exist in the IRRT LLVM module")
+        });
+        global.set_initializer(&exn_id);
+    }
+
    irrt_mod
 }

@ -57,7 +76,7 @@ pub fn integer_power<'ctx, G: CodeGenerator + ?Sized>(
        (64, 64, true) => "__nac3_int_exp_int64_t",
        (32, 32, false) => "__nac3_int_exp_uint32_t",
        (64, 64, false) => "__nac3_int_exp_uint64_t",
-        _ => unreachable!(),
+        _ => codegen_unreachable!(ctx),
    };
    let base_type = base.get_type();
    let pow_fun = ctx.module.get_function(symbol).unwrap_or_else(|| {
@ -443,7 +462,7 @@ pub fn list_slice_assignment<'ctx, G: CodeGenerator + ?Sized>(
                    BasicTypeEnum::IntType(t) => t.size_of(),
                    BasicTypeEnum::PointerType(t) => t.size_of(),
                    BasicTypeEnum::StructType(t) => t.size_of().unwrap(),
-                    _ => unreachable!(),
+                    _ => codegen_unreachable!(ctx),
                };
                ctx.builder.build_int_truncate_or_bit_cast(s, int32, "size").unwrap()
            }
@ -570,7 +589,8 @@ pub fn call_j0<'ctx>(ctx: &CodeGenContext<'ctx, '_>, v: FloatValue<'ctx>) -> Flo
 ///
 /// * `dims` - An [`ArrayLikeIndexer`] containing the size of each dimension.
 /// * `range` - The dimension index to begin and end (exclusively) calculating the dimensions for,
-/// or [`None`] if starting from the first dimension and ending at the last dimension respectively.
+///   or [`None`] if starting from the first dimension and ending at the last dimension
+///   respectively.
 pub fn call_ndarray_calc_size<'ctx, G, Dims>(
    generator: &G,
    ctx: &CodeGenContext<'ctx, '_>,
@ -587,7 +607,7 @@ where
    let ndarray_calc_size_fn_name = match llvm_usize.get_bit_width() {
        32 => "__nac3_ndarray_calc_size",
        64 => "__nac3_ndarray_calc_size64",
-        bw => unreachable!("Unsupported size type bit width: {}", bw),
+        bw => codegen_unreachable!(ctx, "Unsupported size type bit width: {}", bw),
    };
    let ndarray_calc_size_fn_t = llvm_usize.fn_type(
        &[llvm_pusize.into(), llvm_usize.into(), llvm_usize.into(), llvm_usize.into()],
@ -638,7 +658,7 @@ pub fn call_ndarray_calc_nd_indices<'ctx, G: CodeGenerator + ?Sized>(
    let ndarray_calc_nd_indices_fn_name = match llvm_usize.get_bit_width() {
        32 => "__nac3_ndarray_calc_nd_indices",
        64 => "__nac3_ndarray_calc_nd_indices64",
-        bw => unreachable!("Unsupported size type bit width: {}", bw),
+        bw => codegen_unreachable!(ctx, "Unsupported size type bit width: {}", bw),
    };
    let ndarray_calc_nd_indices_fn =
        ctx.module.get_function(ndarray_calc_nd_indices_fn_name).unwrap_or_else(|| {
@ -707,7 +727,7 @@ where
    let ndarray_flatten_index_fn_name = match llvm_usize.get_bit_width() {
        32 => "__nac3_ndarray_flatten_index",
        64 => "__nac3_ndarray_flatten_index64",
-        bw => unreachable!("Unsupported size type bit width: {}", bw),
+        bw => codegen_unreachable!(ctx, "Unsupported size type bit width: {}", bw),
    };
    let ndarray_flatten_index_fn =
        ctx.module.get_function(ndarray_flatten_index_fn_name).unwrap_or_else(|| {
@ -775,7 +795,7 @@ pub fn call_ndarray_calc_broadcast<'ctx, G: CodeGenerator + ?Sized>(
    let ndarray_calc_broadcast_fn_name = match llvm_usize.get_bit_width() {
        32 => "__nac3_ndarray_calc_broadcast",
        64 => "__nac3_ndarray_calc_broadcast64",
-        bw => unreachable!("Unsupported size type bit width: {}", bw),
+        bw => codegen_unreachable!(ctx, "Unsupported size type bit width: {}", bw),
    };
    let ndarray_calc_broadcast_fn =
        ctx.module.get_function(ndarray_calc_broadcast_fn_name).unwrap_or_else(|| {
@ -800,6 +820,7 @@ pub fn call_ndarray_calc_broadcast<'ctx, G: CodeGenerator + ?Sized>(
    gen_for_callback_incrementing(
        generator,
        ctx,
+        None,
        llvm_usize.const_zero(),
        (min_ndims, false),
        |generator, ctx, _, idx| {
@ -894,7 +915,7 @@ pub fn call_ndarray_calc_broadcast_index<
    let ndarray_calc_broadcast_fn_name = match llvm_usize.get_bit_width() {
        32 => "__nac3_ndarray_calc_broadcast_idx",
        64 => "__nac3_ndarray_calc_broadcast_idx64",
-        bw => unreachable!("Unsupported size type bit width: {}", bw),
+        bw => codegen_unreachable!(ctx, "Unsupported size type bit width: {}", bw),
    };
    let ndarray_calc_broadcast_fn =
        ctx.module.get_function(ndarray_calc_broadcast_fn_name).unwrap_or_else(|| {
@ -929,63 +950,3 @@ pub fn call_ndarray_calc_broadcast_index<
        Box::new(|_, v| v.into()),
    )
 }
-
-fn get_size_variant<'ctx>(ty: IntType<'ctx>) -> SizeVariant {
-    match ty.get_bit_width() {
-        32 => SizeVariant::Bits32,
-        64 => SizeVariant::Bits64,
-        _ => unreachable!("Unsupported int type bit width {}", ty.get_bit_width()),
-    }
-}
-
-fn get_size_type_dependent_function<'ctx, BuildFuncTypeFn>(
-    ctx: &CodeGenContext<'ctx, '_>,
-    size_type: IntType<'ctx>,
-    base_name: &str,
-    build_func_type: BuildFuncTypeFn,
-) -> FunctionValue<'ctx>
-where
-    BuildFuncTypeFn: Fn() -> FunctionType<'ctx>,
-{
-    let mut fn_name = base_name.to_owned();
-    match get_size_variant(size_type) {
-        SizeVariant::Bits32 => {
-            // The original fn_name is the correct function name
-        }
-        SizeVariant::Bits64 => {
-            // Append "64" at the end, this is the naming convention for 64-bit
-            fn_name.push_str("64");
-        }
-    }
-
-    // Get (or declare then get if does not exist) the corresponding function
-    ctx.module.get_function(&fn_name).unwrap_or_else(|| {
-        let fn_type = build_func_type();
-        ctx.module.add_function(&fn_name, fn_type, None)
-    })
-}
-
-fn get_ndarray_struct_ptr<'ctx>(ctx: &'ctx Context, size_type: IntType<'ctx>) -> PointerType<'ctx> {
-    let i8_type = ctx.i8_type();
-
-    let ndarray_ty = NpArrayType { size_type, elem_type: i8_type.as_basic_type_enum() };
-    let struct_ty = ndarray_ty.fields().whole_struct.as_struct_type(ctx);
-    struct_ty.ptr_type(AddressSpace::default())
-}
-
-pub fn call_nac3_ndarray_size<'ctx>(
-    ctx: &CodeGenContext<'ctx, '_>,
-    ndarray: NpArrayValue<'ctx>,
-) -> IntValue<'ctx> {
-    let size_type = ndarray.ty.size_type;
-    let function = get_size_type_dependent_function(ctx, size_type, "__nac3_ndarray_size", || {
-        size_type.fn_type(&[get_ndarray_struct_ptr(ctx.ctx, size_type).into()], false)
-    });
-
-    ctx.builder
-        .build_call(function, &[ndarray.ptr.into()], "size")
-        .unwrap()
-        .try_as_basic_value()
-        .unwrap_left()
-        .into_int_value()
-}
--- a/nac3core/src/codegen/irrt/test.rs
+++ b/nac3core/src/codegen/irrt/test.rs
@ -1,26 +0,0 @@
-#[cfg(test)]
-mod tests {
-    use std::{path::Path, process::Command};
-
-    #[test]
-    fn run_irrt_test() {
-        assert!(
-            cfg!(feature = "test"),
-            "Please do `cargo test -F test` to compile `irrt_test.out` and run test"
-        );
-
-        let irrt_test_out_path = Path::new(concat!(env!("OUT_DIR"), "/irrt_test.out"));
-        let output = Command::new(irrt_test_out_path.to_str().unwrap()).output().unwrap();
-
-        if !output.status.success() {
-            eprintln!("irrt_test failed with status {}:", output.status);
-            eprintln!("====== stdout ======");
-            eprintln!("{}", String::from_utf8(output.stdout).unwrap());
-            eprintln!("====== stderr ======");
-            eprintln!("{}", String::from_utf8(output.stderr).unwrap());
-            eprintln!("====================");
-
-            panic!("irrt_test failed");
-        }
-    }
-}
--- a/nac3core/src/codegen/llvm_intrinsics.rs
+++ b/nac3core/src/codegen/llvm_intrinsics.rs
@ -1,12 +1,14 @@
-use crate::codegen::CodeGenContext;
-use inkwell::context::Context;
-use inkwell::intrinsics::Intrinsic;
-use inkwell::types::AnyTypeEnum::IntType;
-use inkwell::types::FloatType;
-use inkwell::values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue, PointerValue};
-use inkwell::AddressSpace;
+use inkwell::{
+    context::Context,
+    intrinsics::Intrinsic,
+    types::{AnyTypeEnum::IntType, FloatType},
+    values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue, PointerValue},
+    AddressSpace,
+};
 use itertools::Either;

+use super::CodeGenContext;
+
 /// Returns the string representation for the floating-point type `ft` when used in intrinsic
 /// functions.
 fn get_float_intrinsic_repr(ctx: &Context, ft: FloatType) -> &'static str {
@ -35,6 +37,40 @@ fn get_float_intrinsic_repr(ctx: &Context, ft: FloatType) -> &'static str {
    unreachable!()
 }

+/// Invokes the [`llvm.va_start`](https://llvm.org/docs/LangRef.html#llvm-va-start-intrinsic)
+/// intrinsic.
+pub fn call_va_start<'ctx>(ctx: &CodeGenContext<'ctx, '_>, arglist: PointerValue<'ctx>) {
+    const FN_NAME: &str = "llvm.va_start";
+
+    let intrinsic_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let llvm_void = ctx.ctx.void_type();
+        let llvm_i8 = ctx.ctx.i8_type();
+        let llvm_p0i8 = llvm_i8.ptr_type(AddressSpace::default());
+        let fn_type = llvm_void.fn_type(&[llvm_p0i8.into()], false);
+
+        ctx.module.add_function(FN_NAME, fn_type, None)
+    });
+
+    ctx.builder.build_call(intrinsic_fn, &[arglist.into()], "").unwrap();
+}
+
+/// Invokes the [`llvm.va_start`](https://llvm.org/docs/LangRef.html#llvm-va-start-intrinsic)
+/// intrinsic.
+pub fn call_va_end<'ctx>(ctx: &CodeGenContext<'ctx, '_>, arglist: PointerValue<'ctx>) {
+    const FN_NAME: &str = "llvm.va_end";
+
+    let intrinsic_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let llvm_void = ctx.ctx.void_type();
+        let llvm_i8 = ctx.ctx.i8_type();
+        let llvm_p0i8 = llvm_i8.ptr_type(AddressSpace::default());
+        let fn_type = llvm_void.fn_type(&[llvm_p0i8.into()], false);
+
+        ctx.module.add_function(FN_NAME, fn_type, None)
+    });
+
+    ctx.builder.build_call(intrinsic_fn, &[arglist.into()], "").unwrap();
+}
+
 /// Invokes the [`llvm.stacksave`](https://llvm.org/docs/LangRef.html#llvm-stacksave-intrinsic)
 /// intrinsic.
 pub fn call_stacksave<'ctx>(
@ -149,7 +185,7 @@ pub fn call_memcpy_generic<'ctx>(
        dest
    } else {
        ctx.builder
-            .build_bitcast(dest, llvm_p0i8, "")
+            .build_bit_cast(dest, llvm_p0i8, "")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap()
    };
@ -157,7 +193,7 @@ pub fn call_memcpy_generic<'ctx>(
        src
    } else {
        ctx.builder
-            .build_bitcast(src, llvm_p0i8, "")
+            .build_bit_cast(src, llvm_p0i8, "")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap()
    };
@ -171,8 +207,9 @@ pub fn call_memcpy_generic<'ctx>(
 /// * `$ctx:ident`: Reference to the current Code Generation Context
 /// * `$name:ident`: Optional name to be assigned to the llvm build call (Option<&str>)
 /// * `$llvm_name:literal`: Name of underlying llvm intrinsic function
-/// * `$map_fn:ident`: Mapping function to be applied on `BasicValue` (`BasicValue` -> Function Return Type)
-/// Use `BasicValueEnum::into_int_value` for Integer return type and `BasicValueEnum::into_float_value` for Float return type
+/// * `$map_fn:ident`: Mapping function to be applied on `BasicValue` (`BasicValue` -> Function Return Type).
+///   Use `BasicValueEnum::into_int_value` for Integer return type and
+///   `BasicValueEnum::into_float_value` for Float return type
 /// * `$llvm_ty:ident`: Type of first operand
 /// * `,($val:ident)*`: Comma separated list of operands
 macro_rules! generate_llvm_intrinsic_fn_body {
@ -188,7 +225,7 @@ macro_rules! generate_llvm_intrinsic_fn_body {
 /// Arguments:
 /// * `float/int`: Indicates the return and argument type of the function
 /// * `$fn_name:ident`: The identifier of the rust function to be generated
-/// * `$llvm_name:literal`: Name of underlying llvm intrinsic function
+/// * `$llvm_name:literal`: Name of underlying llvm intrinsic function.
 ///   Omit "llvm." prefix from the function name i.e. use "ceil" instead of "llvm.ceil"
 /// * `$val:ident`: The operand for unary operations
 /// * `$val1:ident`, `$val2:ident`: The operands for binary operations
--- a/nac3core/src/codegen/mod.rs
+++ b/nac3core/src/codegen/mod.rs
@ -1,12 +1,12 @@
-use crate::{
-    codegen::classes::{ListType, NDArrayType, ProxyType, RangeType},
-    symbol_resolver::{StaticValue, SymbolResolver},
-    toplevel::{helper::PrimDef, numpy::unpack_ndarray_var_tys, TopLevelContext, TopLevelDef},
-    typecheck::{
-        type_inferencer::{CodeLocation, PrimitiveStore},
-        typedef::{CallId, FuncArg, Type, TypeEnum, Unifier},
+use std::{
+    collections::{HashMap, HashSet},
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
    },
+    thread,
 };
+
 use crossbeam::channel::{unbounded, Receiver, Sender};
 use inkwell::{
    attributes::{Attribute, AttributeLoc},
@ -24,14 +24,21 @@ use inkwell::{
    AddressSpace, IntPredicate, OptimizationLevel,
 };
 use itertools::Itertools;
-use nac3parser::ast::{Location, Stmt, StrRef};
 use parking_lot::{Condvar, Mutex};
-use std::collections::{HashMap, HashSet};
-use std::sync::{
-    atomic::{AtomicBool, Ordering},
-    Arc,
+
+use nac3parser::ast::{Location, Stmt, StrRef};
+
+use crate::{
+    symbol_resolver::{StaticValue, SymbolResolver},
+    toplevel::{helper::PrimDef, numpy::unpack_ndarray_var_tys, TopLevelContext, TopLevelDef},
+    typecheck::{
+        type_inferencer::{CodeLocation, PrimitiveStore},
+        typedef::{CallId, FuncArg, Type, TypeEnum, Unifier},
+    },
 };
-use std::thread;
+use classes::{ListType, NDArrayType, ProxyType, RangeType};
+use concrete_type::{ConcreteType, ConcreteTypeEnum, ConcreteTypeStore};
+pub use generator::{CodeGenerator, DefaultCodeGenerator};

 pub mod builtin_fns;
 pub mod classes;
@ -47,8 +54,21 @@ pub mod stmt;
 #[cfg(test)]
 mod test;

-use concrete_type::{ConcreteType, ConcreteTypeEnum, ConcreteTypeStore};
-pub use generator::{CodeGenerator, DefaultCodeGenerator};
+mod macros {
+    /// Codegen-variant of [`std::unreachable`] which accepts an instance of [`CodeGenContext`] as
+    /// its first argument to provide Python source information to indicate the codegen location
+    /// causing the assertion.
+    macro_rules! codegen_unreachable {
+        ($ctx:expr $(,)?) => {
+            std::unreachable!("unreachable code while processing {}", &$ctx.current_loc)
+        };
+        ($ctx:expr, $($arg:tt)*) => {
+            std::unreachable!("unreachable code while processing {}: {}", &$ctx.current_loc, std::format!("{}", std::format_args!($($arg)+)))
+        };
+    }
+
+    pub(crate) use codegen_unreachable;
+}

 #[derive(Default)]
 pub struct StaticValueStore {
@ -68,6 +88,16 @@ pub struct CodeGenLLVMOptions {
    pub target: CodeGenTargetMachineOptions,
 }

+impl CodeGenLLVMOptions {
+    /// Creates a [`TargetMachine`] using the target options specified by this struct.
+    ///
+    /// See [`Target::create_target_machine`].
+    #[must_use]
+    pub fn create_target_machine(&self) -> Option<TargetMachine> {
+        self.target.create_target_machine(self.opt_level)
+    }
+}
+
 /// Additional options for code generation for the target machine.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct CodeGenTargetMachineOptions {
@ -338,6 +368,10 @@ impl WorkerRegistry {
        let mut builder = context.create_builder();
        let mut module = context.create_module(generator.get_name());

+        let target_machine = self.llvm_options.create_target_machine().unwrap();
+        module.set_data_layout(&target_machine.get_target_data().get_data_layout());
+        module.set_triple(&target_machine.get_triple());
+
        module.add_basic_value_flag(
            "Debug Info Version",
            inkwell::module::FlagBehavior::Warning,
@ -361,6 +395,10 @@ impl WorkerRegistry {
                    errors.insert(e);
                    // create a new empty module just to continue codegen and collect errors
                    module = context.create_module(&format!("{}_recover", generator.get_name()));
+
+                    let target_machine = self.llvm_options.create_target_machine().unwrap();
+                    module.set_data_layout(&target_machine.get_target_data().get_data_layout());
+                    module.set_triple(&target_machine.get_triple());
                }
            }
            *self.task_count.lock() -= 1;
@ -426,7 +464,7 @@ pub struct CodeGenTask {
 fn get_llvm_type<'ctx, G: CodeGenerator + ?Sized>(
    ctx: &'ctx Context,
    module: &Module<'ctx>,
-    generator: &mut G,
+    generator: &G,
    unifier: &mut Unifier,
    top_level: &TopLevelContext,
    type_cache: &mut HashMap<Type, BasicTypeEnum<'ctx>>,
@ -520,8 +558,10 @@ fn get_llvm_type<'ctx, G: CodeGenerator + ?Sized>(
                };
                return ty;
            }
-            TTuple { ty } => {
+            TTuple { ty, is_vararg_ctx } => {
                // a struct with fields in the order present in the tuple
+                assert!(!is_vararg_ctx, "Tuples in vararg context must be instantiated with the correct number of arguments before calling get_llvm_type");
+
                let fields = ty
                    .iter()
                    .map(|ty| {
@ -551,7 +591,7 @@ fn get_llvm_type<'ctx, G: CodeGenerator + ?Sized>(
 fn get_llvm_abi_type<'ctx, G: CodeGenerator + ?Sized>(
    ctx: &'ctx Context,
    module: &Module<'ctx>,
-    generator: &mut G,
+    generator: &G,
    unifier: &mut Unifier,
    top_level: &TopLevelContext,
    type_cache: &mut HashMap<Type, BasicTypeEnum<'ctx>>,
@ -560,11 +600,11 @@ fn get_llvm_abi_type<'ctx, G: CodeGenerator + ?Sized>(
 ) -> BasicTypeEnum<'ctx> {
    // If the type is used in the definition of a function, return `i1` instead of `i8` for ABI
    // consistency.
-    return if unifier.unioned(ty, primitives.bool) {
+    if unifier.unioned(ty, primitives.bool) {
        ctx.bool_type().into()
    } else {
        get_llvm_type(ctx, module, generator, unifier, top_level, type_cache, ty)
-    };
+    }
 }

 /// Whether `sret` is needed for a return value with type `ty`.
@ -589,6 +629,40 @@ fn need_sret(ty: BasicTypeEnum) -> bool {
    need_sret_impl(ty, true)
 }

+/// Returns the [`BasicTypeEnum`] representing a `va_list` struct for variadic arguments.
+fn get_llvm_valist_type<'ctx>(ctx: &'ctx Context, triple: &TargetTriple) -> BasicTypeEnum<'ctx> {
+    let triple = TargetMachine::normalize_triple(triple);
+    let triple = triple.as_str().to_str().unwrap();
+    let arch = triple.split('-').next().unwrap();
+
+    let llvm_pi8 = ctx.i8_type().ptr_type(AddressSpace::default());
+
+    // Referenced from parseArch() in llvm/lib/Support/Triple.cpp
+    match arch {
+        "i386" | "i486" | "i586" | "i686" | "riscv32" => {
+            ctx.i8_type().ptr_type(AddressSpace::default()).into()
+        }
+        "amd64" | "x86_64" | "x86_64h" => {
+            let llvm_i32 = ctx.i32_type();
+
+            let va_list_tag = ctx.opaque_struct_type("struct.__va_list_tag");
+            va_list_tag.set_body(
+                &[llvm_i32.into(), llvm_i32.into(), llvm_pi8.into(), llvm_pi8.into()],
+                false,
+            );
+            va_list_tag.into()
+        }
+        "armv7" => {
+            let va_list = ctx.opaque_struct_type("struct.__va_list");
+            va_list.set_body(&[llvm_pi8.into()], false);
+            va_list.into()
+        }
+        triple => {
+            todo!("Unsupported platform for varargs: {triple}")
+        }
+    }
+}
+
 /// Implementation for generating LLVM IR for a function.
 pub fn gen_func_impl<
    'ctx,
@ -700,6 +774,7 @@ pub fn gen_func_impl<
                name: arg.name,
                ty: task.store.to_unifier_type(&mut unifier, &primitives, arg.ty, &mut cache),
                default_value: arg.default_value.clone(),
+                is_vararg: arg.is_vararg,
            })
            .collect_vec(),
        task.store.to_unifier_type(&mut unifier, &primitives, *ret, &mut cache),
@ -722,7 +797,10 @@ pub fn gen_func_impl<
    let has_sret = ret_type.map_or(false, |ty| need_sret(ty));
    let mut params = args
        .iter()
+        .filter(|arg| !arg.is_vararg)
        .map(|arg| {
+            debug_assert!(!arg.is_vararg);
+
            get_llvm_abi_type(
                context,
                &module,
@ -741,9 +819,12 @@ pub fn gen_func_impl<
        params.insert(0, ret_type.unwrap().ptr_type(AddressSpace::default()).into());
    }

+    debug_assert!(matches!(args.iter().filter(|arg| arg.is_vararg).count(), 0..=1));
+    let vararg_arg = args.iter().find(|arg| arg.is_vararg);
+
    let fn_type = match ret_type {
-        Some(ret_type) if !has_sret => ret_type.fn_type(&params, false),
-        _ => context.void_type().fn_type(&params, false),
+        Some(ret_type) if !has_sret => ret_type.fn_type(&params, vararg_arg.is_some()),
+        _ => context.void_type().fn_type(&params, vararg_arg.is_some()),
    };

    let symbol = &task.symbol_name;
@ -771,9 +852,10 @@ pub fn gen_func_impl<
    builder.position_at_end(init_bb);
    let body_bb = context.append_basic_block(fn_val, "body");

+    // Store non-vararg argument values into local variables
    let mut var_assignment = HashMap::new();
    let offset = u32::from(has_sret);
-    for (n, arg) in args.iter().enumerate() {
+    for (n, arg) in args.iter().enumerate().filter(|(_, arg)| !arg.is_vararg) {
        let param = fn_val.get_nth_param((n as u32) + offset).unwrap();
        let local_type = get_llvm_type(
            context,
@ -806,6 +888,8 @@ pub fn gen_func_impl<
        var_assignment.insert(arg.name, (alloca, None, 0));
    }

+    // TODO: Save vararg parameters as list
+
    let return_buffer = if has_sret {
        Some(fn_val.get_nth_param(0).unwrap().into_pointer_value())
    } else {
@ -1028,3 +1112,9 @@ fn gen_in_range_check<'ctx>(

    ctx.builder.build_int_compare(IntPredicate::SLT, lo, hi, "cmp").unwrap()
 }
+
+/// Returns the internal name for the `va_count` argument, used to indicate the number of arguments
+/// passed to the variadic function.
+fn get_va_count_arg_name(arg_name: StrRef) -> StrRef {
+    format!("__{}_va_count", &arg_name).into()
+}
--- a/nac3core/src/codegen/numpy.rs
+++ b/nac3core/src/codegen/numpy.rs
--- a/nac3core/src/codegen/stmt.rs
+++ b/nac3core/src/codegen/stmt.rs
@ -1,21 +1,3 @@
-use super::{
-    super::symbol_resolver::ValueEnum,
-    expr::destructure_range,
-    irrt::{handle_slice_indices, list_slice_assignment},
-    CodeGenContext, CodeGenerator,
-};
-use crate::{
-    codegen::{
-        classes::{ArrayLikeIndexer, ArraySliceValue, ListValue, RangeValue},
-        expr::gen_binop_expr,
-        gen_in_range_check,
-    },
-    toplevel::{helper::PrimDef, numpy::unpack_ndarray_var_tys, DefinitionId, TopLevelDef},
-    typecheck::{
-        magic_methods::Binop,
-        typedef::{FunSignature, Type, TypeEnum},
-    },
-};
 use inkwell::{
    attributes::{Attribute, AttributeLoc},
    basic_block::BasicBlock,
@ -23,10 +5,28 @@ use inkwell::{
    values::{BasicValue, BasicValueEnum, FunctionValue, IntValue, PointerValue},
    IntPredicate,
 };
+use itertools::{izip, Itertools};
+
 use nac3parser::ast::{
    Constant, ExcepthandlerKind, Expr, ExprKind, Location, Stmt, StmtKind, StrRef,
 };
-use std::convert::TryFrom;
+
+use super::{
+    classes::{ArrayLikeIndexer, ArraySliceValue, ListValue, RangeValue},
+    expr::{destructure_range, gen_binop_expr},
+    gen_in_range_check,
+    irrt::{handle_slice_indices, list_slice_assignment},
+    macros::codegen_unreachable,
+    CodeGenContext, CodeGenerator,
+};
+use crate::{
+    symbol_resolver::ValueEnum,
+    toplevel::{DefinitionId, TopLevelDef},
+    typecheck::{
+        magic_methods::Binop,
+        typedef::{iter_type_vars, FunSignature, Type, TypeEnum},
+    },
+};

 /// See [`CodeGenerator::gen_var_alloc`].
 pub fn gen_var<'ctx>(
@ -97,8 +97,6 @@ pub fn gen_store_target<'ctx, G: CodeGenerator>(
    pattern: &Expr<Option<Type>>,
    name: Option<&str>,
 ) -> Result<Option<PointerValue<'ctx>>, String> {
-    let llvm_usize = generator.get_size_type(ctx.ctx);
-
    // very similar to gen_expr, but we don't do an extra load at the end
    // and we flatten nested tuples
    Ok(Some(match &pattern.node {
@ -123,7 +121,7 @@ pub fn gen_store_target<'ctx, G: CodeGenerator>(
                return Ok(None);
            };
            let BasicValueEnum::PointerValue(ptr) = val else {
-                unreachable!();
+                codegen_unreachable!(ctx);
            };
            unsafe {
                ctx.builder.build_in_bounds_gep(
@ -137,66 +135,7 @@ pub fn gen_store_target<'ctx, G: CodeGenerator>(
            }
            .unwrap()
        }
-        ExprKind::Subscript { value, slice, .. } => {
-            match ctx.unifier.get_ty_immutable(value.custom.unwrap()).as_ref() {
-                TypeEnum::TObj { obj_id, .. } if *obj_id == PrimDef::List.id() => {
-                    let v = generator
-                        .gen_expr(ctx, value)?
-                        .unwrap()
-                        .to_basic_value_enum(ctx, generator, value.custom.unwrap())?
-                        .into_pointer_value();
-                    let v = ListValue::from_ptr_val(v, llvm_usize, None);
-                    let len = v.load_size(ctx, Some("len"));
-                    let raw_index = generator
-                        .gen_expr(ctx, slice)?
-                        .unwrap()
-                        .to_basic_value_enum(ctx, generator, slice.custom.unwrap())?
-                        .into_int_value();
-                    let raw_index = ctx
-                        .builder
-                        .build_int_s_extend(raw_index, generator.get_size_type(ctx.ctx), "sext")
-                        .unwrap();
-                    // handle negative index
-                    let is_negative = ctx
-                        .builder
-                        .build_int_compare(
-                            IntPredicate::SLT,
-                            raw_index,
-                            generator.get_size_type(ctx.ctx).const_zero(),
-                            "is_neg",
-                        )
-                        .unwrap();
-                    let adjusted = ctx.builder.build_int_add(raw_index, len, "adjusted").unwrap();
-                    let index = ctx
-                        .builder
-                        .build_select(is_negative, adjusted, raw_index, "index")
-                        .map(BasicValueEnum::into_int_value)
-                        .unwrap();
-                    // unsigned less than is enough, because negative index after adjustment is
-                    // bigger than the length (for unsigned cmp)
-                    let bound_check = ctx
-                        .builder
-                        .build_int_compare(IntPredicate::ULT, index, len, "inbound")
-                        .unwrap();
-                    ctx.make_assert(
-                        generator,
-                        bound_check,
-                        "0:IndexError",
-                        "index {0} out of bounds 0:{1}",
-                        [Some(raw_index), Some(len), None],
-                        slice.location,
-                    );
-                    v.data().ptr_offset(ctx, generator, &index, name)
-                }
-
-                TypeEnum::TObj { obj_id, .. } if *obj_id == PrimDef::NDArray.id() => {
-                    todo!()
-                }
-
-                _ => unreachable!(),
-            }
-        }
-        _ => unreachable!(),
+        _ => codegen_unreachable!(ctx),
    }))
 }

@ -206,70 +145,20 @@ pub fn gen_assign<'ctx, G: CodeGenerator>(
    ctx: &mut CodeGenContext<'ctx, '_>,
    target: &Expr<Option<Type>>,
    value: ValueEnum<'ctx>,
+    value_ty: Type,
 ) -> Result<(), String> {
-    let llvm_usize = generator.get_size_type(ctx.ctx);
-
+    // See https://docs.python.org/3/reference/simple_stmts.html#assignment-statements.
    match &target.node {
-        ExprKind::Tuple { elts, .. } => {
-            let BasicValueEnum::StructValue(v) =
-                value.to_basic_value_enum(ctx, generator, target.custom.unwrap())?
-            else {
-                unreachable!()
-            };
-
-            for (i, elt) in elts.iter().enumerate() {
-                let v = ctx
-                    .builder
-                    .build_extract_value(v, u32::try_from(i).unwrap(), "struct_elem")
-                    .unwrap();
-                generator.gen_assign(ctx, elt, v.into())?;
+        ExprKind::Subscript { value: target, slice: key, .. } => {
+            // Handle "slicing" or "subscription"
+            generator.gen_setitem(ctx, target, key, value, value_ty)?;
        }
-        }
-        ExprKind::Subscript { value: ls, slice, .. }
-            if matches!(&slice.node, ExprKind::Slice { .. }) =>
-        {
-            let ExprKind::Slice { lower, upper, step } = &slice.node else { unreachable!() };
-
-            let ls = generator
-                .gen_expr(ctx, ls)?
-                .unwrap()
-                .to_basic_value_enum(ctx, generator, ls.custom.unwrap())?
-                .into_pointer_value();
-            let ls = ListValue::from_ptr_val(ls, llvm_usize, None);
-            let Some((start, end, step)) =
-                handle_slice_indices(lower, upper, step, ctx, generator, ls.load_size(ctx, None))?
-            else {
-                return Ok(());
-            };
-            let value = value
-                .to_basic_value_enum(ctx, generator, target.custom.unwrap())?
-                .into_pointer_value();
-            let value = ListValue::from_ptr_val(value, llvm_usize, None);
-            let ty = match &*ctx.unifier.get_ty_immutable(target.custom.unwrap()) {
-                TypeEnum::TObj { obj_id, params, .. } if *obj_id == PrimDef::List.id() => {
-                    *params.iter().next().unwrap().1
-                }
-                TypeEnum::TObj { obj_id, .. } if *obj_id == PrimDef::NDArray.id() => {
-                    unpack_ndarray_var_tys(&mut ctx.unifier, target.custom.unwrap()).0
-                }
-                _ => unreachable!(),
-            };
-
-            let ty = ctx.get_llvm_type(generator, ty);
-            let Some(src_ind) = handle_slice_indices(
-                &None,
-                &None,
-                &None,
-                ctx,
-                generator,
-                value.load_size(ctx, None),
-            )?
-            else {
-                return Ok(());
-            };
-            list_slice_assignment(generator, ctx, ty, ls, (start, end, step), value, src_ind);
+        ExprKind::Tuple { elts, .. } | ExprKind::List { elts, .. } => {
+            // Fold on `"[" [target_list] "]"` and `"(" [target_list] ")"`
+            generator.gen_assign_target_list(ctx, elts, value, value_ty)?;
        }
        _ => {
+            // Handle attribute and direct variable assignments.
            let name = if let ExprKind::Name { id, .. } = &target.node {
                format!("{id}.addr")
            } else {
@ -287,19 +176,259 @@ pub fn gen_assign<'ctx, G: CodeGenerator>(
                }
            }
            let val = value.to_basic_value_enum(ctx, generator, target.custom.unwrap())?;
+
+            // Perform i1 <-> i8 conversion as needed
+            let val = if ctx.unifier.unioned(target.custom.unwrap(), ctx.primitives.bool) {
+                generator.bool_to_i8(ctx, val.into_int_value()).into()
+            } else {
+                val
+            };
+
            ctx.builder.build_store(ptr, val).unwrap();
        }
    };
    Ok(())
 }

+/// See [`CodeGenerator::gen_assign_target_list`].
+pub fn gen_assign_target_list<'ctx, G: CodeGenerator>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    targets: &Vec<Expr<Option<Type>>>,
+    value: ValueEnum<'ctx>,
+    value_ty: Type,
+) -> Result<(), String> {
+    // Deconstruct the tuple `value`
+    let BasicValueEnum::StructValue(tuple) = value.to_basic_value_enum(ctx, generator, value_ty)?
+    else {
+        codegen_unreachable!(ctx)
+    };
+
+    // NOTE: Currently, RHS's type is forced to be a Tuple by the type inferencer.
+    let TypeEnum::TTuple { ty: tuple_tys, .. } = &*ctx.unifier.get_ty(value_ty) else {
+        codegen_unreachable!(ctx);
+    };
+
+    assert_eq!(tuple.get_type().count_fields() as usize, tuple_tys.len());
+
+    let tuple = (0..tuple.get_type().count_fields())
+        .map(|i| ctx.builder.build_extract_value(tuple, i, "item").unwrap())
+        .collect_vec();
+
+    // Find the starred target if it exists.
+    let mut starred_target_index: Option<usize> = None; // Index of the "starred" target. If it exists, there may only be one.
+    for (i, target) in targets.iter().enumerate() {
+        if matches!(target.node, ExprKind::Starred { .. }) {
+            assert!(starred_target_index.is_none()); // The typechecker ensures this
+            starred_target_index = Some(i);
+        }
+    }
+
+    if let Some(starred_target_index) = starred_target_index {
+        assert!(tuple_tys.len() >= targets.len() - 1); // The typechecker ensures this
+
+        let a = starred_target_index; // Number of RHS values before the starred target
+        let b = tuple_tys.len() - (targets.len() - 1 - starred_target_index); // Number of RHS values after the starred target
+                                                                              // Thus `tuple[a..b]` is assigned to the starred target.
+
+        // Handle assignment before the starred target
+        for (target, val, val_ty) in
+            izip!(&targets[..starred_target_index], &tuple[..a], &tuple_tys[..a])
+        {
+            generator.gen_assign(ctx, target, ValueEnum::Dynamic(*val), *val_ty)?;
+        }
+
+        // Handle assignment to the starred target
+        if let ExprKind::Starred { value: target, .. } = &targets[starred_target_index].node {
+            let vals = &tuple[a..b];
+            let val_tys = &tuple_tys[a..b];
+
+            // Create a sub-tuple from `value` for the starred target.
+            let sub_tuple_ty = ctx
+                .ctx
+                .struct_type(&vals.iter().map(BasicValueEnum::get_type).collect_vec(), false);
+            let psub_tuple_val =
+                ctx.builder.build_alloca(sub_tuple_ty, "starred_target_value_ptr").unwrap();
+            for (i, val) in vals.iter().enumerate() {
+                let pitem = ctx
+                    .builder
+                    .build_struct_gep(psub_tuple_val, i as u32, "starred_target_value_item")
+                    .unwrap();
+                ctx.builder.build_store(pitem, *val).unwrap();
+            }
+            let sub_tuple_val =
+                ctx.builder.build_load(psub_tuple_val, "starred_target_value").unwrap();
+
+            // Create the typechecker type of the sub-tuple
+            let sub_tuple_ty =
+                ctx.unifier.add_ty(TypeEnum::TTuple { ty: val_tys.to_vec(), is_vararg_ctx: false });
+
+            // Now assign with that sub-tuple to the starred target.
+            generator.gen_assign(ctx, target, ValueEnum::Dynamic(sub_tuple_val), sub_tuple_ty)?;
+        } else {
+            codegen_unreachable!(ctx) // The typechecker ensures this
+        }
+
+        // Handle assignment after the starred target
+        for (target, val, val_ty) in
+            izip!(&targets[starred_target_index + 1..], &tuple[b..], &tuple_tys[b..])
+        {
+            generator.gen_assign(ctx, target, ValueEnum::Dynamic(*val), *val_ty)?;
+        }
+    } else {
+        assert_eq!(tuple_tys.len(), targets.len()); // The typechecker ensures this
+
+        for (target, val, val_ty) in izip!(targets, tuple, tuple_tys) {
+            generator.gen_assign(ctx, target, ValueEnum::Dynamic(val), *val_ty)?;
+        }
+    }
+    Ok(())
+}
+
+/// See [`CodeGenerator::gen_setitem`].
+pub fn gen_setitem<'ctx, G: CodeGenerator>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    target: &Expr<Option<Type>>,
+    key: &Expr<Option<Type>>,
+    value: ValueEnum<'ctx>,
+    value_ty: Type,
+) -> Result<(), String> {
+    let target_ty = target.custom.unwrap();
+    let key_ty = key.custom.unwrap();
+
+    match &*ctx.unifier.get_ty(target_ty) {
+        TypeEnum::TObj { obj_id, params: list_params, .. }
+            if *obj_id == ctx.primitives.list.obj_id(&ctx.unifier).unwrap() =>
+        {
+            // Handle list item assignment
+            let llvm_usize = generator.get_size_type(ctx.ctx);
+            let target_item_ty = iter_type_vars(list_params).next().unwrap().ty;
+
+            let target = generator
+                .gen_expr(ctx, target)?
+                .unwrap()
+                .to_basic_value_enum(ctx, generator, target_ty)?
+                .into_pointer_value();
+            let target = ListValue::from_ptr_val(target, llvm_usize, None);
+
+            if let ExprKind::Slice { .. } = &key.node {
+                // Handle assigning to a slice
+                let ExprKind::Slice { lower, upper, step } = &key.node else {
+                    codegen_unreachable!(ctx)
+                };
+                let Some((start, end, step)) = handle_slice_indices(
+                    lower,
+                    upper,
+                    step,
+                    ctx,
+                    generator,
+                    target.load_size(ctx, None),
+                )?
+                else {
+                    return Ok(());
+                };
+
+                let value =
+                    value.to_basic_value_enum(ctx, generator, value_ty)?.into_pointer_value();
+                let value = ListValue::from_ptr_val(value, llvm_usize, None);
+
+                let target_item_ty = ctx.get_llvm_type(generator, target_item_ty);
+                let Some(src_ind) = handle_slice_indices(
+                    &None,
+                    &None,
+                    &None,
+                    ctx,
+                    generator,
+                    value.load_size(ctx, None),
+                )?
+                else {
+                    return Ok(());
+                };
+                list_slice_assignment(
+                    generator,
+                    ctx,
+                    target_item_ty,
+                    target,
+                    (start, end, step),
+                    value,
+                    src_ind,
+                );
+            } else {
+                // Handle assigning to an index
+                let len = target.load_size(ctx, Some("len"));
+
+                let index = generator
+                    .gen_expr(ctx, key)?
+                    .unwrap()
+                    .to_basic_value_enum(ctx, generator, key_ty)?
+                    .into_int_value();
+                let index = ctx
+                    .builder
+                    .build_int_s_extend(index, generator.get_size_type(ctx.ctx), "sext")
+                    .unwrap();
+
+                // handle negative index
+                let is_negative = ctx
+                    .builder
+                    .build_int_compare(
+                        IntPredicate::SLT,
+                        index,
+                        generator.get_size_type(ctx.ctx).const_zero(),
+                        "is_neg",
+                    )
+                    .unwrap();
+                let adjusted = ctx.builder.build_int_add(index, len, "adjusted").unwrap();
+                let index = ctx
+                    .builder
+                    .build_select(is_negative, adjusted, index, "index")
+                    .map(BasicValueEnum::into_int_value)
+                    .unwrap();
+
+                // unsigned less than is enough, because negative index after adjustment is
+                // bigger than the length (for unsigned cmp)
+                let bound_check = ctx
+                    .builder
+                    .build_int_compare(IntPredicate::ULT, index, len, "inbound")
+                    .unwrap();
+                ctx.make_assert(
+                    generator,
+                    bound_check,
+                    "0:IndexError",
+                    "index {0} out of bounds 0:{1}",
+                    [Some(index), Some(len), None],
+                    key.location,
+                );
+
+                // Write value to index on list
+                let item_ptr =
+                    target.data().ptr_offset(ctx, generator, &index, Some("list_item_ptr"));
+                let value = value.to_basic_value_enum(ctx, generator, value_ty)?;
+                ctx.builder.build_store(item_ptr, value).unwrap();
+            }
+        }
+        TypeEnum::TObj { obj_id, .. }
+            if *obj_id == ctx.primitives.ndarray.obj_id(&ctx.unifier).unwrap() =>
+        {
+            // Handle NDArray item assignment
+            todo!("ndarray subscript assignment is not yet implemented");
+        }
+        _ => {
+            panic!("encountered unknown target type: {}", ctx.unifier.stringify(target_ty));
+        }
+    }
+    Ok(())
+}
+
 /// See [`CodeGenerator::gen_for`].
 pub fn gen_for<G: CodeGenerator>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'_, '_>,
    stmt: &Stmt<Option<Type>>,
 ) -> Result<(), String> {
-    let StmtKind::For { iter, target, body, orelse, .. } = &stmt.node else { unreachable!() };
+    let StmtKind::For { iter, target, body, orelse, .. } = &stmt.node else {
+        codegen_unreachable!(ctx)
+    };

    // var_assignment static values may be changed in another branch
    // if so, remove the static value as it may not be correct in this branch
@ -315,9 +444,6 @@ pub fn gen_for<G: CodeGenerator>(
    let orelse_bb =
        if orelse.is_empty() { cont_bb } else { ctx.ctx.append_basic_block(current, "for.orelse") };

-    // Whether the iterable is a range() expression
-    let is_iterable_range_expr = ctx.unifier.unioned(iter.custom.unwrap(), ctx.primitives.range);
-
    // The BB containing the increment expression
    let incr_bb = ctx.ctx.append_basic_block(current, "for.incr");
    // The BB containing the loop condition check
@ -326,27 +452,35 @@ pub fn gen_for<G: CodeGenerator>(
    // store loop bb information and restore it later
    let loop_bb = ctx.loop_target.replace((incr_bb, cont_bb));

+    let iter_ty = iter.custom.unwrap();
    let iter_val = if let Some(v) = generator.gen_expr(ctx, iter)? {
-        v.to_basic_value_enum(ctx, generator, iter.custom.unwrap())?
+        v.to_basic_value_enum(ctx, generator, iter_ty)?
    } else {
        return Ok(());
    };
-    if is_iterable_range_expr {
+
+    match &*ctx.unifier.get_ty(iter_ty) {
+        TypeEnum::TObj { obj_id, .. }
+            if *obj_id == ctx.primitives.range.obj_id(&ctx.unifier).unwrap() =>
+        {
            let iter_val = RangeValue::from_ptr_val(iter_val.into_pointer_value(), Some("range"));
            // Internal variable for loop; Cannot be assigned
            let i = generator.gen_var_alloc(ctx, int32.into(), Some("for.i.addr"))?;
            // Variable declared in "target" expression of the loop; Can be reassigned *or* shadowed
-        let Some(target_i) = generator.gen_store_target(ctx, target, Some("for.target.addr"))?
+            let Some(target_i) =
+                generator.gen_store_target(ctx, target, Some("for.target.addr"))?
            else {
-            unreachable!()
+                codegen_unreachable!(ctx)
            };
            let (start, stop, step) = destructure_range(ctx, iter_val);

            ctx.builder.build_store(i, start).unwrap();

            // Check "If step is zero, ValueError is raised."
-        let rangenez =
-            ctx.builder.build_int_compare(IntPredicate::NE, step, int32.const_zero(), "").unwrap();
+            let rangenez = ctx
+                .builder
+                .build_int_compare(IntPredicate::NE, step, int32.const_zero(), "")
+                .unwrap();
            ctx.make_assert(
                generator,
                rangenez,
@ -363,7 +497,10 @@ pub fn gen_for<G: CodeGenerator>(
                    .build_conditional_branch(
                        gen_in_range_check(
                            ctx,
-                        ctx.builder.build_load(i, "").map(BasicValueEnum::into_int_value).unwrap(),
+                            ctx.builder
+                                .build_load(i, "")
+                                .map(BasicValueEnum::into_int_value)
+                                .unwrap(),
                            stop,
                            step,
                        ),
@ -393,7 +530,10 @@ pub fn gen_for<G: CodeGenerator>(
                )
                .unwrap();
            generator.gen_block(ctx, body.iter())?;
-    } else {
+        }
+        TypeEnum::TObj { obj_id, params: list_params, .. }
+            if *obj_id == ctx.primitives.list.obj_id(&ctx.unifier).unwrap() =>
+        {
            let index_addr = generator.gen_var_alloc(ctx, size_t.into(), Some("for.index.addr"))?;
            ctx.builder.build_store(index_addr, size_t.const_zero()).unwrap();
            let len = ctx
@ -431,9 +571,14 @@ pub fn gen_for<G: CodeGenerator>(
                .map(BasicValueEnum::into_int_value)
                .unwrap();
            let val = ctx.build_gep_and_load(arr_ptr, &[index], Some("val"));
-        generator.gen_assign(ctx, target, val.into())?;
+            let val_ty = iter_type_vars(list_params).next().unwrap().ty;
+            generator.gen_assign(ctx, target, val.into(), val_ty)?;
            generator.gen_block(ctx, body.iter())?;
        }
+        _ => {
+            panic!("unsupported for loop iterator type: {}", ctx.unifier.stringify(iter_ty));
+        }
+    }

    for (k, (_, _, counter)) in &var_assignment {
        let (_, static_val, counter2) = ctx.var_assignment.get_mut(k).unwrap();
@ -494,6 +639,7 @@ pub struct BreakContinueHooks<'ctx> {
 pub fn gen_for_callback<'ctx, 'a, G, I, InitFn, CondFn, BodyFn, UpdateFn>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, 'a>,
+    label: Option<&str>,
    init: InitFn,
    cond: CondFn,
    body: BodyFn,
@ -504,18 +650,24 @@ where
    I: Clone,
    InitFn: FnOnce(&mut G, &mut CodeGenContext<'ctx, 'a>) -> Result<I, String>,
    CondFn: FnOnce(&mut G, &mut CodeGenContext<'ctx, 'a>, I) -> Result<IntValue<'ctx>, String>,
-    BodyFn:
-        FnOnce(&mut G, &mut CodeGenContext<'ctx, 'a>, BreakContinueHooks, I) -> Result<(), String>,
+    BodyFn: FnOnce(
+        &mut G,
+        &mut CodeGenContext<'ctx, 'a>,
+        BreakContinueHooks<'ctx>,
+        I,
+    ) -> Result<(), String>,
    UpdateFn: FnOnce(&mut G, &mut CodeGenContext<'ctx, 'a>, I) -> Result<(), String>,
 {
+    let label = label.unwrap_or("for");
+
    let current_bb = ctx.builder.get_insert_block().unwrap();
-    let init_bb = ctx.ctx.insert_basic_block_after(current_bb, "for.init");
+    let init_bb = ctx.ctx.insert_basic_block_after(current_bb, &format!("{label}.init"));
    // The BB containing the loop condition check
-    let cond_bb = ctx.ctx.insert_basic_block_after(init_bb, "for.cond");
-    let body_bb = ctx.ctx.insert_basic_block_after(cond_bb, "for.body");
+    let cond_bb = ctx.ctx.insert_basic_block_after(init_bb, &format!("{label}.cond"));
+    let body_bb = ctx.ctx.insert_basic_block_after(cond_bb, &format!("{label}.body"));
    // The BB containing the increment expression
-    let update_bb = ctx.ctx.insert_basic_block_after(body_bb, "for.update");
-    let cont_bb = ctx.ctx.insert_basic_block_after(update_bb, "for.end");
+    let update_bb = ctx.ctx.insert_basic_block_after(body_bb, &format!("{label}.update"));
+    let cont_bb = ctx.ctx.insert_basic_block_after(update_bb, &format!("{label}.end"));

    // store loop bb information and restore it later
    let loop_bb = ctx.loop_target.replace((update_bb, cont_bb));
@ -572,6 +724,7 @@ where
 pub fn gen_for_callback_incrementing<'ctx, 'a, G, BodyFn>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, 'a>,
+    label: Option<&str>,
    init_val: IntValue<'ctx>,
    max_val: (IntValue<'ctx>, bool),
    body: BodyFn,
@ -582,7 +735,7 @@ where
    BodyFn: FnOnce(
        &mut G,
        &mut CodeGenContext<'ctx, 'a>,
-        BreakContinueHooks,
+        BreakContinueHooks<'ctx>,
        IntValue<'ctx>,
    ) -> Result<(), String>,
 {
@ -591,6 +744,7 @@ where
    gen_for_callback(
        generator,
        ctx,
+        label,
        |generator, ctx| {
            let i_addr = generator.gen_var_alloc(ctx, init_val_t.into(), None)?;
            ctx.builder.build_store(i_addr, init_val).unwrap();
@ -642,9 +796,11 @@ where
 /// - `step_fn`: A lambda of IR statements that retrieves the `step` value of the  `range`-like
 ///   iterable. This value will be extended to the size of `start`.
 /// - `body_fn`: A lambda of IR statements within the loop body.
+#[allow(clippy::too_many_arguments)]
 pub fn gen_for_range_callback<'ctx, 'a, G, StartFn, StopFn, StepFn, BodyFn>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, 'a>,
+    label: Option<&str>,
    is_unsigned: bool,
    start_fn: StartFn,
    (stop_fn, stop_inclusive): (StopFn, bool),
@ -656,13 +812,19 @@ where
    StartFn: Fn(&mut G, &mut CodeGenContext<'ctx, 'a>) -> Result<IntValue<'ctx>, String>,
    StopFn: Fn(&mut G, &mut CodeGenContext<'ctx, 'a>) -> Result<IntValue<'ctx>, String>,
    StepFn: Fn(&mut G, &mut CodeGenContext<'ctx, 'a>) -> Result<IntValue<'ctx>, String>,
-    BodyFn: FnOnce(&mut G, &mut CodeGenContext<'ctx, 'a>, IntValue<'ctx>) -> Result<(), String>,
+    BodyFn: FnOnce(
+        &mut G,
+        &mut CodeGenContext<'ctx, 'a>,
+        BreakContinueHooks<'ctx>,
+        IntValue<'ctx>,
+    ) -> Result<(), String>,
 {
    let init_val_t = start_fn(generator, ctx).map(IntValue::get_type).unwrap();

    gen_for_callback(
        generator,
        ctx,
+        label,
        |generator, ctx| {
            let i_addr = generator.gen_var_alloc(ctx, init_val_t.into(), None)?;

@ -720,10 +882,10 @@ where

            Ok(cond)
        },
-        |generator, ctx, _, (i_addr, _)| {
+        |generator, ctx, hooks, (i_addr, _)| {
            let i = ctx.builder.build_load(i_addr, "").map(BasicValueEnum::into_int_value).unwrap();

-            body_fn(generator, ctx, i)
+            body_fn(generator, ctx, hooks, i)
        },
        |generator, ctx, (i_addr, _)| {
            let i = ctx.builder.build_load(i_addr, "").map(BasicValueEnum::into_int_value).unwrap();
@ -751,7 +913,7 @@ pub fn gen_while<G: CodeGenerator>(
    ctx: &mut CodeGenContext<'_, '_>,
    stmt: &Stmt<Option<Type>>,
 ) -> Result<(), String> {
-    let StmtKind::While { test, body, orelse, .. } = &stmt.node else { unreachable!() };
+    let StmtKind::While { test, body, orelse, .. } = &stmt.node else { codegen_unreachable!(ctx) };

    // var_assignment static values may be changed in another branch
    // if so, remove the static value as it may not be correct in this branch
@ -781,7 +943,7 @@ pub fn gen_while<G: CodeGenerator>(

        return Ok(());
    };
-    let BasicValueEnum::IntValue(test) = test else { unreachable!() };
+    let BasicValueEnum::IntValue(test) = test else { codegen_unreachable!(ctx) };

    ctx.builder
        .build_conditional_branch(generator.bool_to_i1(ctx, test), body_bb, orelse_bb)
@ -929,7 +1091,7 @@ pub fn gen_if<G: CodeGenerator>(
    ctx: &mut CodeGenContext<'_, '_>,
    stmt: &Stmt<Option<Type>>,
 ) -> Result<(), String> {
-    let StmtKind::If { test, body, orelse, .. } = &stmt.node else { unreachable!() };
+    let StmtKind::If { test, body, orelse, .. } = &stmt.node else { codegen_unreachable!(ctx) };

    // var_assignment static values may be changed in another branch
    // if so, remove the static value as it may not be correct in this branch
@ -1052,11 +1214,11 @@ pub fn exn_constructor<'ctx>(
    let zelf_id = if let TypeEnum::TObj { obj_id, .. } = &*ctx.unifier.get_ty(zelf_ty) {
        obj_id.0
    } else {
-        unreachable!()
+        codegen_unreachable!(ctx)
    };
    let defs = ctx.top_level.definitions.read();
    let def = defs[zelf_id].read();
-    let TopLevelDef::Class { name: zelf_name, .. } = &*def else { unreachable!() };
+    let TopLevelDef::Class { name: zelf_name, .. } = &*def else { codegen_unreachable!(ctx) };
    let exception_name = format!("{}:{}", ctx.resolver.get_exception_id(zelf_id), zelf_name);
    unsafe {
        let id_ptr = ctx.builder.build_in_bounds_gep(zelf, &[zero, zero], "exn.id").unwrap();
@ -1164,7 +1326,7 @@ pub fn gen_try<'ctx, 'a, G: CodeGenerator>(
    target: &Stmt<Option<Type>>,
 ) -> Result<(), String> {
    let StmtKind::Try { body, handlers, orelse, finalbody, .. } = &target.node else {
-        unreachable!()
+        codegen_unreachable!(ctx)
    };

    // if we need to generate anything related to exception, we must have personality defined
@ -1241,7 +1403,7 @@ pub fn gen_try<'ctx, 'a, G: CodeGenerator>(
            if let TypeEnum::TObj { obj_id, .. } = &*ctx.unifier.get_ty(type_.custom.unwrap()) {
                *obj_id
            } else {
-                unreachable!()
+                codegen_unreachable!(ctx)
            };
        let exception_name = format!("{}:{}", ctx.resolver.get_exception_id(obj_id.0), exn_name);
        let exn_id = ctx.resolver.get_string_id(&exception_name);
@ -1513,6 +1675,23 @@ pub fn gen_return<G: CodeGenerator>(
    } else {
        None
    };
+
+    // Remap boolean return type into i1
+    let value = value.map(|ret_val| {
+        // The "return type" of a sret function is in the first parameter
+        let expected_ty = if ctx.need_sret {
+            func.get_type().get_param_types()[0]
+        } else {
+            func.get_type().get_return_type().unwrap()
+        };
+
+        if matches!(expected_ty, BasicTypeEnum::IntType(ty) if ty.get_bit_width() == 1) {
+            generator.bool_to_i1(ctx, ret_val.into_int_value()).into()
+        } else {
+            ret_val
+        }
+    });
+
    if let Some(return_target) = ctx.return_target {
        if let Some(value) = value {
            ctx.builder.build_store(ctx.return_buffer.unwrap(), value).unwrap();
@ -1523,25 +1702,6 @@ pub fn gen_return<G: CodeGenerator>(
        ctx.builder.build_store(ctx.return_buffer.unwrap(), value.unwrap()).unwrap();
        ctx.builder.build_return(None).unwrap();
    } else {
-        // Remap boolean return type into i1
-        let value = value.map(|v| {
-            let expected_ty = func.get_type().get_return_type().unwrap();
-            let ret_val = v.as_basic_value_enum();
-
-            if expected_ty.is_int_type() && ret_val.is_int_value() {
-                let ret_type = expected_ty.into_int_type();
-                let ret_val = ret_val.into_int_value();
-
-                if ret_type.get_bit_width() == 1 && ret_val.get_type().get_bit_width() != 1 {
-                    generator.bool_to_i1(ctx, ret_val)
-                } else {
-                    ret_val
-                }
-                .into()
-            } else {
-                ret_val
-            }
-        });
        let value = value.as_ref().map(|v| v as &dyn BasicValue);
        ctx.builder.build_return(value).unwrap();
    }
@ -1575,14 +1735,14 @@ pub fn gen_stmt<G: CodeGenerator>(
        }
        StmtKind::AnnAssign { target, value, .. } => {
            if let Some(value) = value {
-                let Some(value) = generator.gen_expr(ctx, value)? else { return Ok(()) };
-                generator.gen_assign(ctx, target, value)?;
+                let Some(value_enum) = generator.gen_expr(ctx, value)? else { return Ok(()) };
+                generator.gen_assign(ctx, target, value_enum, value.custom.unwrap())?;
            }
        }
        StmtKind::Assign { targets, value, .. } => {
-            let Some(value) = generator.gen_expr(ctx, value)? else { return Ok(()) };
+            let Some(value_enum) = generator.gen_expr(ctx, value)? else { return Ok(()) };
            for target in targets {
-                generator.gen_assign(ctx, target, value.clone())?;
+                generator.gen_assign(ctx, target, value_enum.clone(), value.custom.unwrap())?;
            }
        }
        StmtKind::Continue { .. } => {
@ -1596,20 +1756,44 @@ pub fn gen_stmt<G: CodeGenerator>(
        StmtKind::For { .. } => generator.gen_for(ctx, stmt)?,
        StmtKind::With { .. } => generator.gen_with(ctx, stmt)?,
        StmtKind::AugAssign { target, op, value, .. } => {
-            let value = gen_binop_expr(
+            let value_enum = gen_binop_expr(
                generator,
                ctx,
                target,
                Binop::aug_assign(*op),
                value,
                stmt.location,
-            )?;
-            generator.gen_assign(ctx, target, value.unwrap())?;
+            )?
+            .unwrap();
+            generator.gen_assign(ctx, target, value_enum, value.custom.unwrap())?;
        }
        StmtKind::Try { .. } => gen_try(generator, ctx, stmt)?,
        StmtKind::Raise { exc, .. } => {
            if let Some(exc) = exc {
-                let exc = if let Some(v) = generator.gen_expr(ctx, exc)? {
+                let exn = if let ExprKind::Name { id, .. } = &exc.node {
+                    // Handle "raise Exception" short form
+                    let def_id = ctx.resolver.get_identifier_def(*id).map_err(|e| {
+                        format!("{} (at {})", e.iter().next().unwrap(), exc.location)
+                    })?;
+                    let def = ctx.top_level.definitions.read();
+                    let TopLevelDef::Class { constructor, .. } = *def[def_id.0].read() else {
+                        return Err(format!("Failed to resolve symbol {id} (at {})", exc.location));
+                    };
+
+                    let TypeEnum::TFunc(signature) =
+                        ctx.unifier.get_ty(constructor.unwrap()).as_ref().clone()
+                    else {
+                        return Err(format!("Failed to resolve symbol {id} (at {})", exc.location));
+                    };
+
+                    generator
+                        .gen_call(ctx, None, (&signature, def_id), Vec::default())?
+                        .map(Into::into)
+                } else {
+                    generator.gen_expr(ctx, exc)?
+                };
+
+                let exc = if let Some(v) = exn {
                    v.to_basic_value_enum(ctx, generator, exc.custom.unwrap())?
                } else {
                    return Ok(());
@ -1633,17 +1817,48 @@ pub fn gen_stmt<G: CodeGenerator>(
                        return Ok(());
                    }
                }
-                None => ctx.gen_string(generator, ""),
+                None => ctx.gen_string(generator, "").into(),
            };
            ctx.make_assert_impl(
                generator,
-                test.into_int_value(),
+                generator.bool_to_i1(ctx, test.into_int_value()),
                "0:AssertionError",
                err_msg,
                [None, None, None],
                stmt.location,
            );
        }
+        StmtKind::Global { names, .. } => {
+            let registered_globals = ctx
+                .top_level
+                .definitions
+                .read()
+                .iter()
+                .filter_map(|def| {
+                    if let TopLevelDef::Variable { simple_name, ty, .. } = &*def.read() {
+                        Some((*simple_name, *ty))
+                    } else {
+                        None
+                    }
+                })
+                .collect_vec();
+
+            for id in names {
+                let Some((_, ty)) = registered_globals.iter().find(|(name, _)| name == id) else {
+                    return Err(format!("{id} is not a global at {}", stmt.location));
+                };
+
+                let resolver = ctx.resolver.clone();
+                let ptr = resolver
+                    .get_symbol_value(*id, ctx, generator)
+                    .map(|val| val.to_basic_value_enum(ctx, generator, *ty))
+                    .transpose()?
+                    .map(BasicValueEnum::into_pointer_value)
+                    .unwrap();
+
+                ctx.var_assignment.insert(*id, (ptr, None, 0));
+            }
+        }
        _ => unimplemented!(),
    };
    Ok(())
--- a/nac3core/src/codegen/test.rs
+++ b/nac3core/src/codegen/test.rs
@ -1,34 +1,37 @@
-use crate::{
-    codegen::{
-        classes::{ListType, NDArrayType, ProxyType, RangeType},
-        concrete_type::ConcreteTypeStore,
-        CodeGenContext, CodeGenLLVMOptions, CodeGenTargetMachineOptions, CodeGenTask,
-        CodeGenerator, DefaultCodeGenerator, WithCall, WorkerRegistry,
-    },
-    symbol_resolver::{SymbolResolver, ValueEnum},
-    toplevel::{
-        composer::{ComposerConfig, TopLevelComposer},
-        DefinitionId, FunInstance, TopLevelContext, TopLevelDef,
-    },
-    typecheck::{
-        type_inferencer::{FunctionData, Inferencer, PrimitiveStore},
-        typedef::{FunSignature, FuncArg, Type, TypeEnum, Unifier, VarMap},
-    },
+use std::{
+    collections::{HashMap, HashSet},
+    sync::Arc,
 };
+
 use indexmap::IndexMap;
 use indoc::indoc;
 use inkwell::{
    targets::{InitializationConfig, Target},
    OptimizationLevel,
 };
-use nac3parser::ast::FileName;
 use nac3parser::{
-    ast::{fold::Fold, StrRef},
+    ast::{fold::Fold, FileName, StrRef},
    parser::parse_program,
 };
 use parking_lot::RwLock;
-use std::collections::{HashMap, HashSet};
-use std::sync::Arc;
+
+use super::{
+    classes::{ListType, NDArrayType, ProxyType, RangeType},
+    concrete_type::ConcreteTypeStore,
+    CodeGenContext, CodeGenLLVMOptions, CodeGenTargetMachineOptions, CodeGenTask, CodeGenerator,
+    DefaultCodeGenerator, WithCall, WorkerRegistry,
+};
+use crate::{
+    symbol_resolver::{SymbolResolver, ValueEnum},
+    toplevel::{
+        composer::{ComposerConfig, TopLevelComposer},
+        DefinitionId, FunInstance, TopLevelContext, TopLevelDef,
+    },
+    typecheck::{
+        type_inferencer::{FunctionData, IdentifierInfo, Inferencer, PrimitiveStore},
+        typedef::{FunSignature, FuncArg, Type, TypeEnum, Unifier, VarMap},
+    },
+};

 struct Resolver {
    id_to_type: HashMap<StrRef, Type>,
@ -64,6 +67,7 @@ impl SymbolResolver for Resolver {
        &self,
        _: StrRef,
        _: &mut CodeGenContext<'ctx, '_>,
+        _: &mut dyn CodeGenerator,
    ) -> Option<ValueEnum<'ctx>> {
        unimplemented!()
    }
@ -94,7 +98,7 @@ fn test_primitives() {
        "};
    let statements = parse_program(source, FileName::default()).unwrap();

-    let composer = TopLevelComposer::new(Vec::new(), ComposerConfig::default(), 32).0;
+    let composer = TopLevelComposer::new(Vec::new(), Vec::new(), ComposerConfig::default(), 32).0;
    let mut unifier = composer.unifier.clone();
    let primitives = composer.primitives_ty;
    let top_level = Arc::new(composer.make_top_level_context());
@ -109,8 +113,18 @@ fn test_primitives() {
    let threads = vec![DefaultCodeGenerator::new("test".into(), 32).into()];
    let signature = FunSignature {
        args: vec![
-            FuncArg { name: "a".into(), ty: primitives.int32, default_value: None },
-            FuncArg { name: "b".into(), ty: primitives.int32, default_value: None },
+            FuncArg {
+                name: "a".into(),
+                ty: primitives.int32,
+                default_value: None,
+                is_vararg: false,
+            },
+            FuncArg {
+                name: "b".into(),
+                ty: primitives.int32,
+                default_value: None,
+                is_vararg: false,
+            },
        ],
        ret: primitives.int32,
        vars: VarMap::new(),
@ -128,7 +142,8 @@ fn test_primitives() {
    };
    let mut virtual_checks = Vec::new();
    let mut calls = HashMap::new();
-    let mut identifiers: HashSet<_> = ["a".into(), "b".into()].into();
+    let mut identifiers: HashMap<_, _> =
+        ["a".into(), "b".into()].map(|id| (id, IdentifierInfo::default())).into();
    let mut inferencer = Inferencer {
        top_level: &top_level,
        function_data: &mut function_data,
@ -189,6 +204,8 @@ fn test_primitives() {
        let expected = indoc! {"
            ; ModuleID = 'test'
            source_filename = \"test\"
+            target datalayout = \"e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128\"
+            target triple = \"x86_64-unknown-linux-gnu\"

            ; Function Attrs: mustprogress nofree norecurse nosync nounwind readnone willreturn
            define i32 @testing(i32 %0, i32 %1) local_unnamed_addr #0 !dbg !4 {
@ -246,14 +263,19 @@ fn test_simple_call() {
        "};
    let statements_2 = parse_program(source_2, FileName::default()).unwrap();

-    let composer = TopLevelComposer::new(Vec::new(), ComposerConfig::default(), 32).0;
+    let composer = TopLevelComposer::new(Vec::new(), Vec::new(), ComposerConfig::default(), 32).0;
    let mut unifier = composer.unifier.clone();
    let primitives = composer.primitives_ty;
    let top_level = Arc::new(composer.make_top_level_context());
    unifier.top_level = Some(top_level.clone());

    let signature = FunSignature {
-        args: vec![FuncArg { name: "a".into(), ty: primitives.int32, default_value: None }],
+        args: vec![FuncArg {
+            name: "a".into(),
+            ty: primitives.int32,
+            default_value: None,
+            is_vararg: false,
+        }],
        ret: primitives.int32,
        vars: VarMap::new(),
    };
@ -300,7 +322,8 @@ fn test_simple_call() {
    };
    let mut virtual_checks = Vec::new();
    let mut calls = HashMap::new();
-    let mut identifiers: HashSet<_> = ["a".into(), "foo".into()].into();
+    let mut identifiers: HashMap<_, _> =
+        ["a".into(), "foo".into()].map(|id| (id, IdentifierInfo::default())).into();
    let mut inferencer = Inferencer {
        top_level: &top_level,
        function_data: &mut function_data,
@ -368,6 +391,8 @@ fn test_simple_call() {
        let expected = indoc! {"
            ; ModuleID = 'test'
            source_filename = \"test\"
+            target datalayout = \"e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128\"
+            target triple = \"x86_64-unknown-linux-gnu\"

            ; Function Attrs: mustprogress nofree norecurse nosync nounwind readnone willreturn
            define i32 @testing(i32 %0) local_unnamed_addr #0 !dbg !5 {
--- a/nac3core/src/lib.rs
+++ b/nac3core/src/lib.rs
@ -19,8 +19,11 @@
    clippy::wildcard_imports
 )]

+// users of nac3core need to use the same version of these dependencies, so expose them as nac3core::*
+pub use inkwell;
+pub use nac3parser;
+
 pub mod codegen;
 pub mod symbol_resolver;
 pub mod toplevel;
 pub mod typecheck;
-pub mod util;
--- a/nac3core/src/symbol_resolver.rs
+++ b/nac3core/src/symbol_resolver.rs
@ -1,7 +1,15 @@
-use std::fmt::Debug;
-use std::rc::Rc;
-use std::sync::Arc;
-use std::{collections::HashMap, collections::HashSet, fmt::Display};
+use std::{
+    collections::{HashMap, HashSet},
+    fmt::{Debug, Display},
+    rc::Rc,
+    sync::Arc,
+};
+
+use inkwell::values::{BasicValueEnum, FloatValue, IntValue, PointerValue, StructValue};
+use itertools::{chain, izip, Itertools};
+use parking_lot::RwLock;
+
+use nac3parser::ast::{Constant, Expr, Location, StrRef};

 use crate::{
    codegen::{CodeGenContext, CodeGenerator},
@ -11,10 +19,6 @@ use crate::{
        typedef::{Type, TypeEnum, Unifier, VarMap},
    },
 };
-use inkwell::values::{BasicValueEnum, FloatValue, IntValue, PointerValue, StructValue};
-use itertools::{chain, izip, Itertools};
-use nac3parser::ast::{Constant, Expr, Location, StrRef};
-use parking_lot::RwLock;

 #[derive(Clone, PartialEq, Debug)]
 pub enum SymbolValue {
@ -78,14 +82,14 @@ impl SymbolValue {
            }
            Constant::Tuple(t) => {
                let expected_ty = unifier.get_ty(expected_ty);
-                let TypeEnum::TTuple { ty } = expected_ty.as_ref() else {
+                let TypeEnum::TTuple { ty, is_vararg_ctx } = expected_ty.as_ref() else {
                    return Err(format!(
                        "Expected {:?}, but got Tuple",
                        expected_ty.get_type_name()
                    ));
                };

-                assert_eq!(ty.len(), t.len());
+                assert!(*is_vararg_ctx || ty.len() == t.len());

                let elems = t
                    .iter()
@ -155,7 +159,7 @@ impl SymbolValue {
            SymbolValue::Bool(_) => primitives.bool,
            SymbolValue::Tuple(vs) => {
                let vs_tys = vs.iter().map(|v| v.get_type(primitives, unifier)).collect::<Vec<_>>();
-                unifier.add_ty(TypeEnum::TTuple { ty: vs_tys })
+                unifier.add_ty(TypeEnum::TTuple { ty: vs_tys, is_vararg_ctx: false })
            }
            SymbolValue::OptionSome(_) | SymbolValue::OptionNone => primitives.option,
        }
@ -365,6 +369,7 @@ pub trait SymbolResolver {
        &self,
        str: StrRef,
        ctx: &mut CodeGenContext<'ctx, '_>,
+        generator: &mut dyn CodeGenerator,
    ) -> Option<ValueEnum<'ctx>>;

    fn get_default_param_value(&self, expr: &Expr) -> Option<SymbolValue>;
@ -482,7 +487,7 @@ pub fn parse_type_annotation<T>(
                        parse_type_annotation(resolver, top_level_defs, unifier, primitives, elt)
                    })
                    .collect::<Result<Vec<_>, _>>()?;
-                Ok(unifier.add_ty(TypeEnum::TTuple { ty }))
+                Ok(unifier.add_ty(TypeEnum::TTuple { ty, is_vararg_ctx: false }))
            } else {
                Err(HashSet::from(["Expected multiple elements for tuple".into()]))
            }
--- a/nac3core/src/toplevel/builtins.rs
+++ b/nac3core/src/toplevel/builtins.rs
@ -1,7 +1,5 @@
 use std::iter::once;

-use crate::util::SizeVariant;
-use helper::{debug_assert_prim_is_allowed, make_exception_fields, PrimDefDetails};
 use indexmap::IndexMap;
 use inkwell::{
    attributes::{Attribute, AttributeLoc},
@ -12,22 +10,22 @@ use inkwell::{
 use itertools::Either;
 use strum::IntoEnumIterator;

+use super::{
+    helper::{debug_assert_prim_is_allowed, make_exception_fields, PrimDef, PrimDefDetails},
+    numpy::make_ndarray_ty,
+    *,
+};
 use crate::{
    codegen::{
        builtin_fns,
-        classes::{ArrayLikeValue, NDArrayValue, ProxyValue, RangeValue, TypedArrayLikeAccessor},
-        expr::destructure_range,
-        irrt::*,
+        classes::{ProxyValue, RangeValue},
        numpy::*,
        stmt::exn_constructor,
    },
    symbol_resolver::SymbolValue,
-    toplevel::{helper::PrimDef, numpy::make_ndarray_ty},
    typecheck::typedef::{into_var_map, iter_type_vars, TypeVar, VarMap},
 };

-use super::*;
-
 type BuiltinInfo = Vec<(Arc<RwLock<TopLevelDef>>, Option<Stmt>)>;

 pub fn get_exn_constructor(
@ -46,10 +44,26 @@ pub fn get_exn_constructor(
            name: "msg".into(),
            ty: string,
            default_value: Some(SymbolValue::Str(String::new())),
+            is_vararg: false,
+        },
+        FuncArg {
+            name: "param0".into(),
+            ty: int64,
+            default_value: Some(SymbolValue::I64(0)),
+            is_vararg: false,
+        },
+        FuncArg {
+            name: "param1".into(),
+            ty: int64,
+            default_value: Some(SymbolValue::I64(0)),
+            is_vararg: false,
+        },
+        FuncArg {
+            name: "param2".into(),
+            ty: int64,
+            default_value: Some(SymbolValue::I64(0)),
+            is_vararg: false,
        },
-        FuncArg { name: "param0".into(), ty: int64, default_value: Some(SymbolValue::I64(0)) },
-        FuncArg { name: "param1".into(), ty: int64, default_value: Some(SymbolValue::I64(0)) },
-        FuncArg { name: "param2".into(), ty: int64, default_value: Some(SymbolValue::I64(0)) },
    ];
    let exn_type = unifier.add_ty(TypeEnum::TObj {
        obj_id: DefinitionId(class_id),
@ -115,7 +129,12 @@ fn create_fn_by_codegen(
        signature: unifier.add_ty(TypeEnum::TFunc(FunSignature {
            args: param_ty
                .iter()
-                .map(|p| FuncArg { name: p.1.into(), ty: p.0, default_value: None })
+                .map(|p| FuncArg {
+                    name: p.1.into(),
+                    ty: p.0,
+                    default_value: None,
+                    is_vararg: false,
+                })
                .collect(),
            ret: ret_ty,
            vars: var_map.clone(),
@ -279,12 +298,21 @@ pub fn get_builtins(unifier: &mut Unifier, primitives: &PrimitiveStore) -> Built
        .collect()
 }

-fn size_variant_to_int_type(variant: SizeVariant, primitives: &PrimitiveStore) -> Type {
-    match variant {
+/// A helper enum used by [`BuiltinBuilder`]
+#[derive(Clone, Copy)]
+enum SizeVariant {
+    Bits32,
+    Bits64,
+}
+
+impl SizeVariant {
+    fn of_int(self, primitives: &PrimitiveStore) -> Type {
+        match self {
            SizeVariant::Bits32 => primitives.int32,
            SizeVariant::Bits64 => primitives.int64,
        }
    }
+}

 struct BuiltinBuilder<'a> {
    unifier: &'a mut Unifier,
@ -338,8 +366,8 @@ impl<'a> BuiltinBuilder<'a> {
        let (is_some_ty, unwrap_ty, option_tvar) =
            if let TypeEnum::TObj { fields, params, .. } = unifier.get_ty(option).as_ref() {
                (
-                    *fields.get(&PrimDef::OptionIsSome.simple_name().into()).unwrap(),
-                    *fields.get(&PrimDef::OptionUnwrap.simple_name().into()).unwrap(),
+                    *fields.get(&PrimDef::FunOptionIsSome.simple_name().into()).unwrap(),
+                    *fields.get(&PrimDef::FunOptionUnwrap.simple_name().into()).unwrap(),
                    iter_type_vars(params).next().unwrap(),
                )
            } else {
@ -354,9 +382,9 @@ impl<'a> BuiltinBuilder<'a> {
        let ndarray_dtype_tvar = iter_type_vars(ndarray_params).next().unwrap();
        let ndarray_ndims_tvar = iter_type_vars(ndarray_params).nth(1).unwrap();
        let ndarray_copy_ty =
-            *ndarray_fields.get(&PrimDef::NDArrayCopy.simple_name().into()).unwrap();
+            *ndarray_fields.get(&PrimDef::FunNDArrayCopy.simple_name().into()).unwrap();
        let ndarray_fill_ty =
-            *ndarray_fields.get(&PrimDef::NDArrayFill.simple_name().into()).unwrap();
+            *ndarray_fields.get(&PrimDef::FunNDArrayFill.simple_name().into()).unwrap();

        let num_ty = unifier.get_fresh_var_with_range(
            &[int32, int64, float, boolean, uint32, uint64],
@ -456,14 +484,14 @@ impl<'a> BuiltinBuilder<'a> {
            PrimDef::Exception => self.build_exception_class_related(prim),

            PrimDef::Option
-            | PrimDef::OptionIsSome
-            | PrimDef::OptionIsNone
-            | PrimDef::OptionUnwrap
+            | PrimDef::FunOptionIsSome
+            | PrimDef::FunOptionIsNone
+            | PrimDef::FunOptionUnwrap
            | PrimDef::FunSome => self.build_option_class_related(prim),

            PrimDef::List => self.build_list_class_related(prim),

-            PrimDef::NDArray | PrimDef::NDArrayCopy | PrimDef::NDArrayFill => {
+            PrimDef::NDArray | PrimDef::FunNDArrayCopy | PrimDef::FunNDArrayFill => {
                self.build_ndarray_class_related(prim)
            }

@ -502,7 +530,9 @@ impl<'a> BuiltinBuilder<'a> {

            PrimDef::FunMin | PrimDef::FunMax => self.build_min_max_function(prim),

-            PrimDef::FunNpMin | PrimDef::FunNpMax => self.build_np_min_max_function(prim),
+            PrimDef::FunNpArgmin | PrimDef::FunNpArgmax | PrimDef::FunNpMin | PrimDef::FunNpMax => {
+                self.build_np_max_min_function(prim)
+            }

            PrimDef::FunNpMinimum | PrimDef::FunNpMaximum => {
                self.build_np_minimum_maximum_function(prim)
@ -546,6 +576,22 @@ impl<'a> BuiltinBuilder<'a> {
            | PrimDef::FunNpLdExp
            | PrimDef::FunNpHypot
            | PrimDef::FunNpNextAfter => self.build_np_2ary_function(prim),
+
+            PrimDef::FunNpTranspose | PrimDef::FunNpReshape => {
+                self.build_np_sp_ndarray_function(prim)
+            }
+
+            PrimDef::FunNpDot
+            | PrimDef::FunNpLinalgCholesky
+            | PrimDef::FunNpLinalgQr
+            | PrimDef::FunNpLinalgSvd
+            | PrimDef::FunNpLinalgInv
+            | PrimDef::FunNpLinalgPinv
+            | PrimDef::FunNpLinalgMatrixPower
+            | PrimDef::FunNpLinalgDet
+            | PrimDef::FunSpLinalgLu
+            | PrimDef::FunSpLinalgSchur
+            | PrimDef::FunSpLinalgHessenberg => self.build_linalg_methods(prim),
        };

        if cfg!(debug_assertions) {
@ -554,7 +600,7 @@ impl<'a> BuiltinBuilder<'a> {
            match (&tld, prim.details()) {
                (
                    TopLevelDef::Class { name, object_id, .. },
-                    PrimDefDetails::PrimClass { name: exp_name },
+                    PrimDefDetails::PrimClass { name: exp_name, .. },
                ) => {
                    let exp_object_id = prim.id();
                    assert_eq!(name, &exp_name.into());
@ -603,17 +649,24 @@ impl<'a> BuiltinBuilder<'a> {
        let make_ctor_signature = |unifier: &mut Unifier| {
            unifier.add_ty(TypeEnum::TFunc(FunSignature {
                args: vec![
-                    FuncArg { name: "start".into(), ty: int32, default_value: None },
+                    FuncArg {
+                        name: "start".into(),
+                        ty: int32,
+                        default_value: None,
+                        is_vararg: false,
+                    },
                    FuncArg {
                        name: "stop".into(),
                        ty: int32,
                        // placeholder
                        default_value: Some(SymbolValue::I32(0)),
+                        is_vararg: false,
                    },
                    FuncArg {
                        name: "step".into(),
                        ty: int32,
                        default_value: Some(SymbolValue::I32(1)),
+                        is_vararg: false,
                    },
                ],
                ret: range,
@ -784,9 +837,9 @@ impl<'a> BuiltinBuilder<'a> {
            prim,
            &[
                PrimDef::Option,
-                PrimDef::OptionIsSome,
-                PrimDef::OptionIsNone,
-                PrimDef::OptionUnwrap,
+                PrimDef::FunOptionIsSome,
+                PrimDef::FunOptionIsNone,
+                PrimDef::FunOptionUnwrap,
                PrimDef::FunSome,
            ],
        );
@ -799,9 +852,9 @@ impl<'a> BuiltinBuilder<'a> {
                fields: Vec::default(),
                attributes: Vec::default(),
                methods: vec![
-                    Self::create_method(PrimDef::OptionIsSome, self.is_some_ty.0),
-                    Self::create_method(PrimDef::OptionIsNone, self.is_some_ty.0),
-                    Self::create_method(PrimDef::OptionUnwrap, self.unwrap_ty.0),
+                    Self::create_method(PrimDef::FunOptionIsSome, self.is_some_ty.0),
+                    Self::create_method(PrimDef::FunOptionIsNone, self.is_some_ty.0),
+                    Self::create_method(PrimDef::FunOptionUnwrap, self.unwrap_ty.0),
                ],
                ancestors: vec![TypeAnnotation::CustomClass {
                    id: prim.id(),
@ -812,7 +865,7 @@ impl<'a> BuiltinBuilder<'a> {
                loc: None,
            },

-            PrimDef::OptionUnwrap => TopLevelDef::Function {
+            PrimDef::FunOptionUnwrap => TopLevelDef::Function {
                name: prim.name().into(),
                simple_name: prim.simple_name().into(),
                signature: self.unwrap_ty.0,
@ -826,7 +879,7 @@ impl<'a> BuiltinBuilder<'a> {
                loc: None,
            },

-            PrimDef::OptionIsNone | PrimDef::OptionIsSome => TopLevelDef::Function {
+            PrimDef::FunOptionIsNone | PrimDef::FunOptionIsSome => TopLevelDef::Function {
                name: prim.name().to_string(),
                simple_name: prim.simple_name().into(),
                signature: self.is_some_ty.0,
@ -847,10 +900,10 @@ impl<'a> BuiltinBuilder<'a> {
                        };

                        let returned_int = match prim {
-                            PrimDef::OptionIsNone => {
+                            PrimDef::FunOptionIsNone => {
                                ctx.builder.build_is_null(ptr, prim.simple_name())
                            }
-                            PrimDef::OptionIsSome => {
+                            PrimDef::FunOptionIsSome => {
                                ctx.builder.build_is_not_null(ptr, prim.simple_name())
                            }
                            _ => unreachable!(),
@ -869,6 +922,7 @@ impl<'a> BuiltinBuilder<'a> {
                        name: "n".into(),
                        ty: self.option_tvar.ty,
                        default_value: None,
+                        is_vararg: false,
                    }],
                    ret: self.primitives.option,
                    vars: into_var_map([self.option_tvar]),
@ -923,7 +977,7 @@ impl<'a> BuiltinBuilder<'a> {
    fn build_ndarray_class_related(&self, prim: PrimDef) -> TopLevelDef {
        debug_assert_prim_is_allowed(
            prim,
-            &[PrimDef::NDArray, PrimDef::NDArrayCopy, PrimDef::NDArrayFill],
+            &[PrimDef::NDArray, PrimDef::FunNDArrayCopy, PrimDef::FunNDArrayFill],
        );

        match prim {
@ -934,8 +988,8 @@ impl<'a> BuiltinBuilder<'a> {
                fields: Vec::default(),
                attributes: Vec::default(),
                methods: vec![
-                    Self::create_method(PrimDef::NDArrayCopy, self.ndarray_copy_ty.0),
-                    Self::create_method(PrimDef::NDArrayFill, self.ndarray_fill_ty.0),
+                    Self::create_method(PrimDef::FunNDArrayCopy, self.ndarray_copy_ty.0),
+                    Self::create_method(PrimDef::FunNDArrayFill, self.ndarray_fill_ty.0),
                ],
                ancestors: Vec::default(),
                constructor: None,
@ -943,7 +997,7 @@ impl<'a> BuiltinBuilder<'a> {
                loc: None,
            },

-            PrimDef::NDArrayCopy => TopLevelDef::Function {
+            PrimDef::FunNDArrayCopy => TopLevelDef::Function {
                name: prim.name().into(),
                simple_name: prim.simple_name().into(),
                signature: self.ndarray_copy_ty.0,
@ -953,15 +1007,14 @@ impl<'a> BuiltinBuilder<'a> {
                resolver: None,
                codegen_callback: Some(Arc::new(GenCall::new(Box::new(
                    |ctx, obj, fun, args, generator| {
-                        todo!()
-                        // gen_ndarray_copy(ctx, &obj, fun, &args, generator)
-                        //     .map(|val| Some(val.as_basic_value_enum()))
+                        gen_ndarray_copy(ctx, &obj, fun, &args, generator)
+                            .map(|val| Some(val.as_basic_value_enum()))
                    },
                )))),
                loc: None,
            },

-            PrimDef::NDArrayFill => TopLevelDef::Function {
+            PrimDef::FunNDArrayFill => TopLevelDef::Function {
                name: prim.name().into(),
                simple_name: prim.simple_name().into(),
                signature: self.ndarray_fill_ty.0,
@ -971,9 +1024,8 @@ impl<'a> BuiltinBuilder<'a> {
                resolver: None,
                codegen_callback: Some(Arc::new(GenCall::new(Box::new(
                    |ctx, obj, fun, args, generator| {
-                        todo!()
-                        // gen_ndarray_fill(ctx, &obj, fun, &args, generator)?;
-                        // Ok(None)
+                        gen_ndarray_fill(ctx, &obj, fun, &args, generator)?;
+                        Ok(None)
                    },
                )))),
                loc: None,
@ -1005,6 +1057,7 @@ impl<'a> BuiltinBuilder<'a> {
                    name: "n".into(),
                    ty: self.num_or_ndarray_ty.ty,
                    default_value: None,
+                    is_vararg: false,
                }],
                ret: self.num_or_ndarray_ty.ty,
                vars: self.num_or_ndarray_var_map.clone(),
@ -1053,7 +1106,7 @@ impl<'a> BuiltinBuilder<'a> {
        );

        // The size variant of the function determines the size of the returned int.
-        let int_sized = size_variant_to_int_type(size_variant, self.primitives);
+        let int_sized = size_variant.of_int(self.primitives);

        let ndarray_int_sized =
            make_ndarray_ty(self.unifier, self.primitives, Some(int_sized), Some(common_ndim.ty));
@ -1078,7 +1131,7 @@ impl<'a> BuiltinBuilder<'a> {
                let arg_ty = fun.0.args[0].ty;
                let arg = args[0].1.clone().to_basic_value_enum(ctx, generator, arg_ty)?;

-                let ret_elem_ty = size_variant_to_int_type(size_variant, &ctx.primitives);
+                let ret_elem_ty = size_variant.of_int(&ctx.primitives);
                Ok(Some(builtin_fns::call_round(generator, ctx, (arg_ty, arg), ret_elem_ty)?))
            }),
        )
@ -1119,7 +1172,7 @@ impl<'a> BuiltinBuilder<'a> {
            make_ndarray_ty(self.unifier, self.primitives, Some(float), Some(common_ndim.ty));

        // The size variant of the function determines the type of int returned
-        let int_sized = size_variant_to_int_type(size_variant, self.primitives);
+        let int_sized = size_variant.of_int(self.primitives);
        let ndarray_int_sized =
            make_ndarray_ty(self.unifier, self.primitives, Some(int_sized), Some(common_ndim.ty));

@ -1142,7 +1195,7 @@ impl<'a> BuiltinBuilder<'a> {
                let arg_ty = fun.0.args[0].ty;
                let arg = args[0].1.clone().to_basic_value_enum(ctx, generator, arg_ty)?;

-                let ret_elem_ty = size_variant_to_int_type(size_variant, &ctx.primitives);
+                let ret_elem_ty = size_variant.of_int(&ctx.primitives);
                let func = match kind {
                    Kind::Ceil => builtin_fns::call_ceil,
                    Kind::Floor => builtin_fns::call_floor,
@ -1193,14 +1246,13 @@ impl<'a> BuiltinBuilder<'a> {
            self.ndarray_float,
            &[(self.ndarray_factory_fn_shape_arg_tvar.ty, "shape")],
            Box::new(move |ctx, obj, fun, args, generator| {
-                todo!()
-                // let func = match prim {
-                //     PrimDef::FunNpNDArray | PrimDef::FunNpEmpty => gen_ndarray_empty,
-                //     PrimDef::FunNpZeros => gen_ndarray_zeros,
-                //     PrimDef::FunNpOnes => gen_ndarray_ones,
-                //     _ => unreachable!(),
-                // };
-                // func(ctx, &obj, fun, &args, generator).map(|val| Some(val.as_basic_value_enum()))
+                let func = match prim {
+                    PrimDef::FunNpNDArray | PrimDef::FunNpEmpty => gen_ndarray_empty,
+                    PrimDef::FunNpZeros => gen_ndarray_zeros,
+                    PrimDef::FunNpOnes => gen_ndarray_ones,
+                    _ => unreachable!(),
+                };
+                func(ctx, &obj, fun, &args, generator).map(|val| Some(val.as_basic_value_enum()))
            }),
        )
    }
@ -1225,16 +1277,23 @@ impl<'a> BuiltinBuilder<'a> {
                    simple_name: prim.simple_name().into(),
                    signature: self.unifier.add_ty(TypeEnum::TFunc(FunSignature {
                        args: vec![
-                            FuncArg { name: "object".into(), ty: tv.ty, default_value: None },
+                            FuncArg {
+                                name: "object".into(),
+                                ty: tv.ty,
+                                default_value: None,
+                                is_vararg: false,
+                            },
                            FuncArg {
                                name: "copy".into(),
                                ty: bool,
                                default_value: Some(SymbolValue::Bool(true)),
+                                is_vararg: false,
                            },
                            FuncArg {
                                name: "ndmin".into(),
                                ty: int32,
                                default_value: Some(SymbolValue::U32(0)),
+                                is_vararg: false,
                            },
                        ],
                        ret: ndarray,
@ -1246,9 +1305,8 @@ impl<'a> BuiltinBuilder<'a> {
                    resolver: None,
                    codegen_callback: Some(Arc::new(GenCall::new(Box::new(
                        |ctx, obj, fun, args, generator| {
-                            todo!()
-                            // gen_ndarray_array(ctx, &obj, fun, &args, generator)
-                            //     .map(|val| Some(val.as_basic_value_enum()))
+                            gen_ndarray_array(ctx, &obj, fun, &args, generator)
+                                .map(|val| Some(val.as_basic_value_enum()))
                        },
                    )))),
                    loc: None,
@ -1266,9 +1324,8 @@ impl<'a> BuiltinBuilder<'a> {
                    // type variable
                    &[(self.list_int32, "shape"), (tv.ty, "fill_value")],
                    Box::new(move |ctx, obj, fun, args, generator| {
-                        todo!()
-                        // gen_ndarray_full(ctx, &obj, fun, &args, generator)
-                        //     .map(|val| Some(val.as_basic_value_enum()))
+                        gen_ndarray_full(ctx, &obj, fun, &args, generator)
+                            .map(|val| Some(val.as_basic_value_enum()))
                    }),
                )
            }
@ -1278,17 +1335,24 @@ impl<'a> BuiltinBuilder<'a> {
                    simple_name: prim.simple_name().into(),
                    signature: self.unifier.add_ty(TypeEnum::TFunc(FunSignature {
                        args: vec![
-                            FuncArg { name: "N".into(), ty: int32, default_value: None },
+                            FuncArg {
+                                name: "N".into(),
+                                ty: int32,
+                                default_value: None,
+                                is_vararg: false,
+                            },
                            // TODO(Derppening): Default values current do not work?
                            FuncArg {
                                name: "M".into(),
                                ty: int32,
                                default_value: Some(SymbolValue::OptionNone),
+                                is_vararg: false,
                            },
                            FuncArg {
                                name: "k".into(),
                                ty: int32,
                                default_value: Some(SymbolValue::I32(0)),
+                                is_vararg: false,
                            },
                        ],
                        ret: self.ndarray_float_2d,
@ -1300,9 +1364,8 @@ impl<'a> BuiltinBuilder<'a> {
                    resolver: None,
                    codegen_callback: Some(Arc::new(GenCall::new(Box::new(
                        |ctx, obj, fun, args, generator| {
-                            todo!()
-                            // gen_ndarray_eye(ctx, &obj, fun, &args, generator)
-                            //     .map(|val| Some(val.as_basic_value_enum()))
+                            gen_ndarray_eye(ctx, &obj, fun, &args, generator)
+                                .map(|val| Some(val.as_basic_value_enum()))
                        },
                    )))),
                    loc: None,
@ -1315,9 +1378,8 @@ impl<'a> BuiltinBuilder<'a> {
                self.ndarray_float_2d,
                &[(int32, "n")],
                Box::new(|ctx, obj, fun, args, generator| {
-                    todo!()
-                    // gen_ndarray_identity(ctx, &obj, fun, &args, generator)
-                    //     .map(|val| Some(val.as_basic_value_enum()))
+                    gen_ndarray_identity(ctx, &obj, fun, &args, generator)
+                        .map(|val| Some(val.as_basic_value_enum()))
                }),
            ),
            _ => unreachable!(),
@ -1334,7 +1396,12 @@ impl<'a> BuiltinBuilder<'a> {
            name: prim.name().into(),
            simple_name: prim.simple_name().into(),
            signature: self.unifier.add_ty(TypeEnum::TFunc(FunSignature {
-                args: vec![FuncArg { name: "s".into(), ty: str, default_value: None }],
+                args: vec![FuncArg {
+                    name: "s".into(),
+                    ty: str,
+                    default_value: None,
+                    is_vararg: false,
+                }],
                ret: str,
                vars: VarMap::default(),
            })),
@ -1398,31 +1465,21 @@ impl<'a> BuiltinBuilder<'a> {
    fn build_len_function(&mut self) -> TopLevelDef {
        let prim = PrimDef::FunLen;

-        let PrimitiveStore { uint64, int32, .. } = *self.primitives;
+        // Type handled in [`Inferencer::try_fold_special_call`]
+        let arg_tvar = self.unifier.get_dummy_var();

-        let tvar = self.unifier.get_fresh_var(Some("L".into()), None);
-        let list = self
-            .unifier
-            .subst(
-                self.primitives.list,
-                &into_var_map([TypeVar { id: self.list_tvar.id, ty: tvar.ty }]),
-            )
-            .unwrap();
-        let ndims = self.unifier.get_fresh_const_generic_var(uint64, Some("N".into()), None);
-        let ndarray = make_ndarray_ty(self.unifier, self.primitives, Some(tvar.ty), Some(ndims.ty));
-
-        let arg_ty = self.unifier.get_fresh_var_with_range(
-            &[list, ndarray, self.primitives.range],
-            Some("I".into()),
-            None,
-        );
        TopLevelDef::Function {
            name: prim.name().into(),
            simple_name: prim.simple_name().into(),
            signature: self.unifier.add_ty(TypeEnum::TFunc(FunSignature {
-                args: vec![FuncArg { name: "ls".into(), ty: arg_ty.ty, default_value: None }],
-                ret: int32,
-                vars: into_var_map([tvar, arg_ty]),
+                args: vec![FuncArg {
+                    name: "obj".into(),
+                    ty: arg_tvar.ty,
+                    default_value: None,
+                    is_vararg: false,
+                }],
+                ret: self.primitives.int32,
+                vars: into_var_map([arg_tvar]),
            })),
            var_id: Vec::default(),
            instance_to_symbol: HashMap::default(),
@ -1430,86 +1487,10 @@ impl<'a> BuiltinBuilder<'a> {
            resolver: None,
            codegen_callback: Some(Arc::new(GenCall::new(Box::new(
                move |ctx, _, fun, args, generator| {
-                    let range_ty = ctx.primitives.range;
                    let arg_ty = fun.0.args[0].ty;
                    let arg = args[0].1.clone().to_basic_value_enum(ctx, generator, arg_ty)?;
-                    Ok(if ctx.unifier.unioned(arg_ty, range_ty) {
-                        let arg = RangeValue::from_ptr_val(arg.into_pointer_value(), Some("range"));
-                        let (start, end, step) = destructure_range(ctx, arg);
-                        Some(calculate_len_for_slice_range(generator, ctx, start, end, step).into())
-                    } else {
-                        match &*ctx.unifier.get_ty_immutable(arg_ty) {
-                            TypeEnum::TObj { obj_id, .. } if *obj_id == PrimDef::List.id() => {
-                                let int32 = ctx.ctx.i32_type();
-                                let zero = int32.const_zero();
-                                let len = ctx
-                                    .build_gep_and_load(
-                                        arg.into_pointer_value(),
-                                        &[zero, int32.const_int(1, false)],
-                                        None,
-                                    )
-                                    .into_int_value();
-                                if len.get_type().get_bit_width() == 32 {
-                                    Some(len.into())
-                                } else {
-                                    Some(
-                                        ctx.builder
-                                            .build_int_truncate(len, int32, "len2i32")
-                                            .map(Into::into)
-                                            .unwrap(),
-                                    )
-                                }
-                            }
-                            TypeEnum::TObj { obj_id, .. } if *obj_id == PrimDef::NDArray.id() => {
-                                let llvm_i32 = ctx.ctx.i32_type();
-                                let llvm_usize = generator.get_size_type(ctx.ctx);

-                                let arg = NDArrayValue::from_ptr_val(
-                                    arg.into_pointer_value(),
-                                    llvm_usize,
-                                    None,
-                                );
-
-                                let ndims = arg.dim_sizes().size(ctx, generator);
-                                ctx.make_assert(
-                                    generator,
-                                    ctx.builder
-                                        .build_int_compare(
-                                            IntPredicate::NE,
-                                            ndims,
-                                            llvm_usize.const_zero(),
-                                            "",
-                                        )
-                                        .unwrap(),
-                                    "0:TypeError",
-                                    &format!("{name}() of unsized object", name = prim.name()),
-                                    [None, None, None],
-                                    ctx.current_loc,
-                                );
-
-                                let len = unsafe {
-                                    arg.dim_sizes().get_typed_unchecked(
-                                        ctx,
-                                        generator,
-                                        &llvm_usize.const_zero(),
-                                        None,
-                                    )
-                                };
-
-                                if len.get_type().get_bit_width() == 32 {
-                                    Some(len.into())
-                                } else {
-                                    Some(
-                                        ctx.builder
-                                            .build_int_truncate(len, llvm_i32, "len")
-                                            .map(Into::into)
-                                            .unwrap(),
-                                    )
-                                }
-                            }
-                            _ => unreachable!(),
-                        }
-                    })
+                    builtin_fns::call_len(generator, ctx, (arg_ty, arg)).map(|ret| Some(ret.into()))
                },
            )))),
            loc: None,
@ -1525,8 +1506,18 @@ impl<'a> BuiltinBuilder<'a> {
            simple_name: prim.simple_name().into(),
            signature: self.unifier.add_ty(TypeEnum::TFunc(FunSignature {
                args: vec![
-                    FuncArg { name: "m".into(), ty: self.num_ty.ty, default_value: None },
-                    FuncArg { name: "n".into(), ty: self.num_ty.ty, default_value: None },
+                    FuncArg {
+                        name: "m".into(),
+                        ty: self.num_ty.ty,
+                        default_value: None,
+                        is_vararg: false,
+                    },
+                    FuncArg {
+                        name: "n".into(),
+                        ty: self.num_ty.ty,
+                        default_value: None,
+                        is_vararg: false,
+                    },
                ],
                ret: self.num_ty.ty,
                vars: self.num_var_map.clone(),
@ -1554,10 +1545,19 @@ impl<'a> BuiltinBuilder<'a> {
        }
    }

-    /// Build the functions `np_min()` and `np_max()`.
-    fn build_np_min_max_function(&mut self, prim: PrimDef) -> TopLevelDef {
-        debug_assert_prim_is_allowed(prim, &[PrimDef::FunNpMin, PrimDef::FunNpMax]);
+    /// Build the functions `np_max()`, `np_min()`, `np_argmax()` and `np_argmin()`
+    /// Calls `call_numpy_max_min` with the function name
+    fn build_np_max_min_function(&mut self, prim: PrimDef) -> TopLevelDef {
+        debug_assert_prim_is_allowed(
+            prim,
+            &[PrimDef::FunNpArgmin, PrimDef::FunNpArgmax, PrimDef::FunNpMin, PrimDef::FunNpMax],
+        );

+        let (var_map, ret_ty) = match prim {
+            PrimDef::FunNpArgmax | PrimDef::FunNpArgmin => {
+                (self.num_or_ndarray_var_map.clone(), self.primitives.int64)
+            }
+            PrimDef::FunNpMax | PrimDef::FunNpMin => {
                let ret_ty = self.unifier.get_fresh_var(Some("R".into()), None);
                let var_map = self
                    .num_or_ndarray_var_map
@ -1565,28 +1565,25 @@ impl<'a> BuiltinBuilder<'a> {
                    .into_iter()
                    .chain(once((ret_ty.id, ret_ty.ty)))
                    .collect::<IndexMap<_, _>>();
+                (var_map, ret_ty.ty)
+            }
+            _ => unreachable!(),
+        };

        create_fn_by_codegen(
            self.unifier,
            &var_map,
            prim.name(),
-            ret_ty.ty,
-            &[(self.float_or_ndarray_ty.ty, "a")],
+            ret_ty,
+            &[(self.num_or_ndarray_ty.ty, "a")],
            Box::new(move |ctx, _, fun, args, generator| {
                let a_ty = fun.0.args[0].ty;
                let a = args[0].1.clone().to_basic_value_enum(ctx, generator, a_ty)?;

-                let func = match prim {
-                    PrimDef::FunNpMin => builtin_fns::call_numpy_min,
-                    PrimDef::FunNpMax => builtin_fns::call_numpy_max,
-                    _ => unreachable!(),
-                };
-
-                Ok(Some(func(generator, ctx, (a_ty, a))?))
+                Ok(Some(builtin_fns::call_numpy_max_min(generator, ctx, (a_ty, a), prim.name())?))
            }),
        )
    }
-
    /// Build the functions `np_minimum()` and `np_maximum()`.
    fn build_np_minimum_maximum_function(&mut self, prim: PrimDef) -> TopLevelDef {
        debug_assert_prim_is_allowed(prim, &[PrimDef::FunNpMinimum, PrimDef::FunNpMaximum]);
@ -1602,7 +1599,12 @@ impl<'a> BuiltinBuilder<'a> {
            signature: self.unifier.add_ty(TypeEnum::TFunc(FunSignature {
                args: param_ty
                    .iter()
-                    .map(|p| FuncArg { name: p.1.into(), ty: p.0, default_value: None })
+                    .map(|p| FuncArg {
+                        name: p.1.into(),
+                        ty: p.0,
+                        default_value: None,
+                        is_vararg: false,
+                    })
                    .collect(),
                ret: ret_ty.ty,
                vars: into_var_map([x1_ty, x2_ty, ret_ty]),
@ -1643,6 +1645,7 @@ impl<'a> BuiltinBuilder<'a> {
                    name: "n".into(),
                    ty: self.num_or_ndarray_ty.ty,
                    default_value: None,
+                    is_vararg: false,
                }],
                ret: self.num_or_ndarray_ty.ty,
                vars: self.num_or_ndarray_var_map.clone(),
@ -1831,7 +1834,12 @@ impl<'a> BuiltinBuilder<'a> {
            signature: self.unifier.add_ty(TypeEnum::TFunc(FunSignature {
                args: param_ty
                    .iter()
-                    .map(|p| FuncArg { name: p.1.into(), ty: p.0, default_value: None })
+                    .map(|p| FuncArg {
+                        name: p.1.into(),
+                        ty: p.0,
+                        default_value: None,
+                        is_vararg: false,
+                    })
                    .collect(),
                ret: ret_ty.ty,
                vars: into_var_map([x1_ty, x2_ty, ret_ty]),
@ -1865,6 +1873,207 @@ impl<'a> BuiltinBuilder<'a> {
        }
    }

+    /// Build np/sp functions that take as input `NDArray` only
+    fn build_np_sp_ndarray_function(&mut self, prim: PrimDef) -> TopLevelDef {
+        debug_assert_prim_is_allowed(prim, &[PrimDef::FunNpTranspose, PrimDef::FunNpReshape]);
+
+        match prim {
+            PrimDef::FunNpTranspose => {
+                let ndarray_ty = self.unifier.get_fresh_var_with_range(
+                    &[self.ndarray_num_ty],
+                    Some("T".into()),
+                    None,
+                );
+                create_fn_by_codegen(
+                    self.unifier,
+                    &into_var_map([ndarray_ty]),
+                    prim.name(),
+                    ndarray_ty.ty,
+                    &[(ndarray_ty.ty, "x")],
+                    Box::new(move |ctx, _, fun, args, generator| {
+                        let arg_ty = fun.0.args[0].ty;
+                        let arg_val =
+                            args[0].1.clone().to_basic_value_enum(ctx, generator, arg_ty)?;
+                        Ok(Some(ndarray_transpose(generator, ctx, (arg_ty, arg_val))?))
+                    }),
+                )
+            }
+
+            // NOTE: on `ndarray_factory_fn_shape_arg_tvar` and
+            // the `param_ty` for `create_fn_by_codegen`.
+            //
+            // Similar to `build_ndarray_from_shape_factory_function` we delegate the responsibility of typechecking
+            // to [`typecheck::type_inferencer::Inferencer::fold_numpy_function_call_shape_argument`],
+            // and use a dummy [`TypeVar`] `ndarray_factory_fn_shape_arg_tvar` as a placeholder for `param_ty`.
+            PrimDef::FunNpReshape => create_fn_by_codegen(
+                self.unifier,
+                &VarMap::new(),
+                prim.name(),
+                self.ndarray_num_ty,
+                &[(self.ndarray_num_ty, "x"), (self.ndarray_factory_fn_shape_arg_tvar.ty, "shape")],
+                Box::new(move |ctx, _, fun, args, generator| {
+                    let x1_ty = fun.0.args[0].ty;
+                    let x1_val = args[0].1.clone().to_basic_value_enum(ctx, generator, x1_ty)?;
+                    let x2_ty = fun.0.args[1].ty;
+                    let x2_val = args[1].1.clone().to_basic_value_enum(ctx, generator, x2_ty)?;
+                    Ok(Some(ndarray_reshape(generator, ctx, (x1_ty, x1_val), (x2_ty, x2_val))?))
+                }),
+            ),
+
+            _ => unreachable!(),
+        }
+    }
+
+    /// Build `np_linalg` and `sp_linalg` functions
+    ///
+    /// The input to these functions must be floating point `NDArray`
+    fn build_linalg_methods(&mut self, prim: PrimDef) -> TopLevelDef {
+        debug_assert_prim_is_allowed(
+            prim,
+            &[
+                PrimDef::FunNpDot,
+                PrimDef::FunNpLinalgCholesky,
+                PrimDef::FunNpLinalgQr,
+                PrimDef::FunNpLinalgSvd,
+                PrimDef::FunNpLinalgInv,
+                PrimDef::FunNpLinalgPinv,
+                PrimDef::FunNpLinalgMatrixPower,
+                PrimDef::FunNpLinalgDet,
+                PrimDef::FunSpLinalgLu,
+                PrimDef::FunSpLinalgSchur,
+                PrimDef::FunSpLinalgHessenberg,
+            ],
+        );
+
+        match prim {
+            PrimDef::FunNpDot => create_fn_by_codegen(
+                self.unifier,
+                &self.num_or_ndarray_var_map,
+                prim.name(),
+                self.num_ty.ty,
+                &[(self.num_or_ndarray_ty.ty, "x1"), (self.num_or_ndarray_ty.ty, "x2")],
+                Box::new(move |ctx, _, fun, args, generator| {
+                    let x1_ty = fun.0.args[0].ty;
+                    let x1_val = args[0].1.clone().to_basic_value_enum(ctx, generator, x1_ty)?;
+                    let x2_ty = fun.0.args[1].ty;
+                    let x2_val = args[1].1.clone().to_basic_value_enum(ctx, generator, x2_ty)?;
+
+                    Ok(Some(ndarray_dot(generator, ctx, (x1_ty, x1_val), (x2_ty, x2_val))?))
+                }),
+            ),
+
+            PrimDef::FunNpLinalgCholesky | PrimDef::FunNpLinalgInv | PrimDef::FunNpLinalgPinv => {
+                create_fn_by_codegen(
+                    self.unifier,
+                    &VarMap::new(),
+                    prim.name(),
+                    self.ndarray_float_2d,
+                    &[(self.ndarray_float_2d, "x1")],
+                    Box::new(move |ctx, _, fun, args, generator| {
+                        let x1_ty = fun.0.args[0].ty;
+                        let x1_val =
+                            args[0].1.clone().to_basic_value_enum(ctx, generator, x1_ty)?;
+
+                        let func = match prim {
+                            PrimDef::FunNpLinalgCholesky => builtin_fns::call_np_linalg_cholesky,
+                            PrimDef::FunNpLinalgInv => builtin_fns::call_np_linalg_inv,
+                            PrimDef::FunNpLinalgPinv => builtin_fns::call_np_linalg_pinv,
+                            _ => unreachable!(),
+                        };
+                        Ok(Some(func(generator, ctx, (x1_ty, x1_val))?))
+                    }),
+                )
+            }
+
+            PrimDef::FunNpLinalgQr
+            | PrimDef::FunSpLinalgLu
+            | PrimDef::FunSpLinalgSchur
+            | PrimDef::FunSpLinalgHessenberg => {
+                let ret_ty = self.unifier.add_ty(TypeEnum::TTuple {
+                    ty: vec![self.ndarray_float_2d, self.ndarray_float_2d],
+                    is_vararg_ctx: false,
+                });
+                create_fn_by_codegen(
+                    self.unifier,
+                    &VarMap::new(),
+                    prim.name(),
+                    ret_ty,
+                    &[(self.ndarray_float_2d, "x1")],
+                    Box::new(move |ctx, _, fun, args, generator| {
+                        let x1_ty = fun.0.args[0].ty;
+                        let x1_val =
+                            args[0].1.clone().to_basic_value_enum(ctx, generator, x1_ty)?;
+
+                        let func = match prim {
+                            PrimDef::FunNpLinalgQr => builtin_fns::call_np_linalg_qr,
+                            PrimDef::FunSpLinalgLu => builtin_fns::call_sp_linalg_lu,
+                            PrimDef::FunSpLinalgSchur => builtin_fns::call_sp_linalg_schur,
+                            PrimDef::FunSpLinalgHessenberg => {
+                                builtin_fns::call_sp_linalg_hessenberg
+                            }
+                            _ => unreachable!(),
+                        };
+                        Ok(Some(func(generator, ctx, (x1_ty, x1_val))?))
+                    }),
+                )
+            }
+
+            PrimDef::FunNpLinalgSvd => {
+                let ret_ty = self.unifier.add_ty(TypeEnum::TTuple {
+                    ty: vec![self.ndarray_float_2d, self.ndarray_float, self.ndarray_float_2d],
+                    is_vararg_ctx: false,
+                });
+                create_fn_by_codegen(
+                    self.unifier,
+                    &VarMap::new(),
+                    prim.name(),
+                    ret_ty,
+                    &[(self.ndarray_float_2d, "x1")],
+                    Box::new(move |ctx, _, fun, args, generator| {
+                        let x1_ty = fun.0.args[0].ty;
+                        let x1_val =
+                            args[0].1.clone().to_basic_value_enum(ctx, generator, x1_ty)?;
+
+                        Ok(Some(builtin_fns::call_np_linalg_svd(generator, ctx, (x1_ty, x1_val))?))
+                    }),
+                )
+            }
+            PrimDef::FunNpLinalgMatrixPower => create_fn_by_codegen(
+                self.unifier,
+                &VarMap::new(),
+                prim.name(),
+                self.ndarray_float_2d,
+                &[(self.ndarray_float_2d, "x1"), (self.primitives.int32, "power")],
+                Box::new(move |ctx, _, fun, args, generator| {
+                    let x1_ty = fun.0.args[0].ty;
+                    let x1_val = args[0].1.clone().to_basic_value_enum(ctx, generator, x1_ty)?;
+                    let x2_ty = fun.0.args[1].ty;
+                    let x2_val = args[1].1.clone().to_basic_value_enum(ctx, generator, x2_ty)?;
+
+                    Ok(Some(builtin_fns::call_np_linalg_matrix_power(
+                        generator,
+                        ctx,
+                        (x1_ty, x1_val),
+                        (x2_ty, x2_val),
+                    )?))
+                }),
+            ),
+            PrimDef::FunNpLinalgDet => create_fn_by_codegen(
+                self.unifier,
+                &VarMap::new(),
+                prim.name(),
+                self.primitives.float,
+                &[(self.ndarray_float_2d, "x1")],
+                Box::new(move |ctx, _, fun, args, generator| {
+                    let x1_ty = fun.0.args[0].ty;
+                    let x1_val = args[0].1.clone().to_basic_value_enum(ctx, generator, x1_ty)?;
+                    Ok(Some(builtin_fns::call_np_linalg_det(generator, ctx, (x1_ty, x1_val))?))
+                }),
+            ),
+            _ => unreachable!(),
+        }
+    }
+
    fn create_method(prim: PrimDef, method_ty: Type) -> (StrRef, Type, DefinitionId) {
        (prim.simple_name().into(), method_ty, prim.id())
    }
--- a/nac3core/src/toplevel/composer.rs
+++ b/nac3core/src/toplevel/composer.rs
@ -1,17 +1,17 @@
-use nac3parser::ast::fold::Fold;
 use std::rc::Rc;

+use nac3parser::ast::{fold::Fold, ExprKind, Ident};
+
+use super::*;
 use crate::{
    codegen::{expr::get_subst_key, stmt::exn_constructor},
    symbol_resolver::SymbolValue,
    typecheck::{
-        type_inferencer::{FunctionData, Inferencer},
+        type_inferencer::{FunctionData, IdentifierInfo, Inferencer},
        typedef::{TypeVar, VarMap},
    },
 };

-use super::*;
-
 pub struct ComposerConfig {
    pub kernel_ann: Option<&'static str>,
    pub kernel_invariant_ann: &'static str,
@ -23,7 +23,7 @@ impl Default for ComposerConfig {
    }
 }

-type DefAst = (Arc<RwLock<TopLevelDef>>, Option<Stmt<()>>);
+pub type DefAst = (Arc<RwLock<TopLevelDef>>, Option<Stmt<()>>);
 pub struct TopLevelComposer {
    // list of top level definitions, same as top level context
    pub definition_ast_list: Vec<DefAst>,
@ -44,12 +44,27 @@ pub struct TopLevelComposer {
    pub size_t: u32,
 }

+/// The specification for a builtin function, consisting of the function name, the function
+/// signature, and a [code generation callback][`GenCall`].
+pub type BuiltinFuncSpec = (StrRef, FunSignature, Arc<GenCall>);
+
+/// A function that creates a [`BuiltinFuncSpec`] using the provided [`PrimitiveStore`] and
+/// [`Unifier`].
+pub type BuiltinFuncCreator = dyn Fn(&PrimitiveStore, &mut Unifier) -> BuiltinFuncSpec;
+
 impl TopLevelComposer {
    /// return a composer and things to make a "primitive" symbol resolver, so that the symbol
-    /// resolver can later figure out primitive type definitions when passed a primitive type name
+    /// resolver can later figure out primitive tye definitions when passed a primitive type name
+    ///
+    /// `lateinit_builtins` are specifically for the ARTIQ module. Since the [`Unifier`] instance
+    /// used to create builtin functions do not persist until method compilation, any types
+    /// created (e.g. [`TypeEnum::TVar`]) also do not persist. Those functions should be instead put
+    /// in `lateinit_builtins`, where they will be instantiated with the [`Unifier`] instance used
+    /// for method compilation.
    #[must_use]
    pub fn new(
-        builtins: Vec<(StrRef, FunSignature, Arc<GenCall>)>,
+        builtins: Vec<BuiltinFuncSpec>,
+        lateinit_builtins: Vec<Box<BuiltinFuncCreator>>,
        core_config: ComposerConfig,
        size_t: u32,
    ) -> (Self, HashMap<StrRef, DefinitionId>, HashMap<StrRef, Type>) {
@ -86,7 +101,8 @@ impl TopLevelComposer {
            .iter()
            .map(|def_ast| match *def_ast.0.read() {
                TopLevelDef::Class { name, .. } => name.to_string(),
-                TopLevelDef::Function { simple_name, .. } => simple_name.to_string(),
+                TopLevelDef::Function { simple_name, .. }
+                | TopLevelDef::Variable { simple_name, .. } => simple_name.to_string(),
            })
            .collect_vec();

@ -119,7 +135,13 @@ impl TopLevelComposer {
            }
        }

-        for (name, sig, codegen_callback) in builtins {
+        // Materialize lateinit_builtins, now that the unifier is ready
+        let lateinit_builtins = lateinit_builtins
+            .into_iter()
+            .map(|builtin| builtin(&primitives_ty, &mut unifier))
+            .collect_vec();
+
+        for (name, sig, codegen_callback) in builtins.into_iter().chain(lateinit_builtins) {
            let fun_sig = unifier.add_ty(TypeEnum::TFunc(sig));
            builtin_ty.insert(name, fun_sig);
            builtin_id.insert(name, DefinitionId(definition_ast_list.len()));
@ -360,13 +382,87 @@ impl TopLevelComposer {
                ))
            }

+            ast::StmtKind::Assign { .. } => {
+                // Assignment statements can assign to (and therefore create) more than one 
+                // variable, but this function only allows returning one set of symbol information.
+                // We want to avoid changing this to return a `Vec` of symbol info, as this would 
+                // require `iter().next().unwrap()` on every variable created from a non-Assign 
+                // statement.
+                //
+                // Make callers use `register_top_level_var` instead, as it provides more
+                // fine-grained control over which symbols to register, while also simplifying the
+                // usage of this function.
+                panic!("Registration of top-level Assign statements must use TopLevelComposer::register_top_level_var (at {})", ast.location);
+            }
+
+            ast::StmtKind::AnnAssign { target, annotation, .. } => {
+                let ExprKind::Name { id: name, .. } = target.node else {
+                    return Err(format!(
+                        "global variable declaration must be an identifier (at {})",
+                        target.location
+                    ));
+                };
+
+                self.register_top_level_var(
+                    name,
+                    Some(annotation.as_ref().clone()),
+                    resolver,
+                    mod_path,
+                    target.location,
+                )
+            }
+
            _ => Err(format!(
-                "registrations of constructs other than top level classes/functions are not supported (at {})",
+                "registrations of constructs other than top level classes/functions/variables are not supported (at {})",
                ast.location
            )),
        }
    }

+    /// Registers a top-level variable with the given `name` into the composer.
+    ///
+    /// `annotation` - The type annotation of the top-level variable, or [`None`] if no type
+    /// annotation is provided.
+    /// `location` - The location of the top-level variable.
+    pub fn register_top_level_var(
+        &mut self,
+        name: Ident,
+        annotation: Option<Expr>,
+        resolver: Option<Arc<dyn SymbolResolver + Send + Sync>>,
+        mod_path: &str,
+        location: Location,
+    ) -> Result<(StrRef, DefinitionId, Option<Type>), String> {
+        if self.keyword_list.contains(&name) {
+            return Err(format!("cannot use keyword `{name}` as a class name (at {location})"));
+        }
+
+        let global_var_name =
+            if mod_path.is_empty() { name.to_string() } else { format!("{mod_path}.{name}") };
+
+        if !self.defined_names.insert(global_var_name.clone()) {
+            return Err(format!(
+                "global variable `{global_var_name}` defined twice (at {location})"
+            ));
+        }
+
+        let ty_to_be_unified = self.unifier.get_dummy_var().ty;
+        self.definition_ast_list.push((
+            RwLock::new(Self::make_top_level_variable_def(
+                global_var_name,
+                name,
+                // dummy here, unify with correct type later,
+                ty_to_be_unified,
+                annotation,
+                resolver,
+                Some(location),
+            ))
+            .into(),
+            None,
+        ));
+
+        Ok((name, DefinitionId(self.definition_ast_list.len() - 1), Some(ty_to_be_unified)))
+    }
+
    pub fn start_analysis(&mut self, inference: bool) -> Result<(), HashSet<String>> {
        self.analyze_top_level_class_type_var()?;
        self.analyze_top_level_class_bases()?;
@ -375,6 +471,7 @@ impl TopLevelComposer {
        if inference {
            self.analyze_function_instance()?;
        }
+        self.analyze_top_level_variables()?;
        Ok(())
    }

@ -412,7 +509,7 @@ impl TopLevelComposer {
                    // things like `class A(Generic[T, V, ImportedModule.T])` is not supported
                    // i.e. only simple names are allowed in the subscript
                    // should update the TopLevelDef::Class.typevars and the TypeEnum::TObj.params
-                    ast::ExprKind::Subscript { value, slice, .. }
+                    ExprKind::Subscript { value, slice, .. }
                        if {
                            matches!(
                                &value.node,
@ -428,9 +525,9 @@ impl TopLevelComposer {
                        }
                        is_generic = true;

-                        let type_var_list: Vec<&ast::Expr<()>>;
+                        let type_var_list: Vec<&Expr<()>>;
                        // if `class A(Generic[T, V, G])`
-                        if let ast::ExprKind::Tuple { elts, .. } = &slice.node {
+                        if let ExprKind::Tuple { elts, .. } = &slice.node {
                            type_var_list = elts.iter().collect_vec();
                        // `class A(Generic[T])`
                        } else {
@ -479,6 +576,7 @@ impl TopLevelComposer {
            }
            Ok(())
        };
+
        let mut errors = HashSet::new();
        for (class_def, class_ast) in def_list.iter().skip(self.builtin_num) {
            if class_ast.is_none() {
@ -766,6 +864,7 @@ impl TopLevelComposer {
            let target_ty = get_type_from_type_annotation_kinds(
                &temp_def_list,
                unifier,
+                primitives,
                &def,
                &mut subst_list,
            )?;
@ -831,7 +930,6 @@ impl TopLevelComposer {
        let unifier = self.unifier.borrow_mut();
        let primitives_store = &self.primitives_ty;

-        let mut errors = HashSet::new();
        let mut analyze = |function_def: &Arc<RwLock<TopLevelDef>>, function_ast: &Option<Stmt>| {
            let mut function_def = function_def.write();
            let function_def = &mut *function_def;
@ -859,7 +957,73 @@ impl TopLevelComposer {
            let resolver = &**resolver;

            let mut function_var_map = VarMap::new();
-            let arg_types = {
+
+            let vararg = args
+                .vararg
+                .as_ref()
+                .map(|vararg| -> Result<_, HashSet<String>> {
+                    let vararg = vararg.as_ref();
+
+                    let annotation = vararg
+                        .node
+                        .annotation
+                        .as_ref()
+                        .ok_or_else(|| {
+                            HashSet::from([format!(
+                                "function parameter `{}` needs type annotation at {}",
+                                vararg.node.arg, vararg.location
+                            )])
+                        })?
+                        .as_ref();
+
+                    let type_annotation = parse_ast_to_type_annotation_kinds(
+                        resolver,
+                        temp_def_list.as_slice(),
+                        unifier,
+                        primitives_store,
+                        annotation,
+                        // NOTE: since only class need this, for function
+                        // it should be fine to be empty map
+                        HashMap::new(),
+                    )?;
+
+                    let type_vars_within =
+                        get_type_var_contained_in_type_annotation(&type_annotation)
+                            .into_iter()
+                            .map(|x| -> Result<TypeVar, HashSet<String>> {
+                                let TypeAnnotation::TypeVar(ty) = x else {
+                                    unreachable!("must be type var annotation kind")
+                                };
+
+                                let id = Self::get_var_id(ty, unifier)?;
+                                Ok(TypeVar { id, ty })
+                            })
+                            .collect::<Result<Vec<_>, _>>()?;
+                    for var in type_vars_within {
+                        if let Some(prev_ty) = function_var_map.insert(var.id, var.ty) {
+                            // if already have the type inserted, make sure they are the same thing
+                            assert_eq!(prev_ty, var.ty);
+                        }
+                    }
+
+                    let ty = get_type_from_type_annotation_kinds(
+                        temp_def_list.as_ref(),
+                        unifier,
+                        primitives_store,
+                        &type_annotation,
+                        &mut None,
+                    )?;
+
+                    Ok(FuncArg {
+                        name: vararg.node.arg,
+                        ty,
+                        default_value: Some(SymbolValue::Tuple(Vec::default())),
+                        is_vararg: true,
+                    })
+                })
+                .transpose()?;
+
+            let mut arg_types = {
                // make sure no duplicate parameter
                let mut defined_parameter_name: HashSet<_> = HashSet::new();
                for x in &args.args {
@ -874,15 +1038,15 @@ impl TopLevelComposer {
                    }
                }

-                let arg_with_default: Vec<(&ast::Located<ast::ArgData<()>>, Option<&ast::Expr>)> =
-                    args.args
+                let arg_with_default: Vec<(&ast::Located<ast::ArgData<()>>, Option<&Expr>)> = args
+                    .args
                    .iter()
                    .rev()
                    .zip(
                        args.defaults
                            .iter()
                            .rev()
-                                .map(|x| -> Option<&ast::Expr> { Some(x) })
+                            .map(|x| -> Option<&Expr> { Some(x) })
                            .chain(std::iter::repeat(None)),
                    )
                    .collect_vec();
@ -936,6 +1100,7 @@ impl TopLevelComposer {
                        let ty = get_type_from_type_annotation_kinds(
                            temp_def_list.as_ref(),
                            unifier,
+                            primitives_store,
                            &type_annotation,
                            &mut None,
                        )?;
@ -959,11 +1124,18 @@ impl TopLevelComposer {
                                    v
                                }),
                            },
+                            is_vararg: false,
                        })
                    })
                    .collect::<Result<Vec<_>, _>>()?
            };

+            if let Some(vararg) = vararg {
+                arg_types.push(vararg);
+            };
+
+            let arg_types = arg_types;
+
            let return_ty = {
                if let Some(returns) = returns {
                    let return_ty_annotation = {
@ -1002,6 +1174,7 @@ impl TopLevelComposer {
                    get_type_from_type_annotation_kinds(
                        &temp_def_list,
                        unifier,
+                        primitives_store,
                        &return_ty_annotation,
                        &mut None,
                    )?
@ -1031,6 +1204,8 @@ impl TopLevelComposer {
            })?;
            Ok(())
        };
+
+        let mut errors = HashSet::new();
        for (function_def, function_ast) in def_list.iter().skip(self.builtin_num) {
            if function_ast.is_none() {
                continue;
@ -1132,7 +1307,7 @@ impl TopLevelComposer {

                        let arg_with_default: Vec<(
                            &ast::Located<ast::ArgData<()>>,
-                            Option<&ast::Expr>,
+                            Option<&Expr>,
                        )> = args
                            .args
                            .iter()
@ -1141,7 +1316,7 @@ impl TopLevelComposer {
                                args.defaults
                                    .iter()
                                    .rev()
-                                    .map(|x| -> Option<&ast::Expr> { Some(x) })
+                                    .map(|x| -> Option<&Expr> { Some(x) })
                                    .chain(std::iter::repeat(None)),
                            )
                            .collect_vec();
@ -1214,6 +1389,7 @@ impl TopLevelComposer {
                                            })
                                        }
                                    },
+                                    is_vararg: false,
                                };
                                // push the dummy type and the type annotation
                                // into the list for later unification
@ -1297,7 +1473,7 @@ impl TopLevelComposer {
                        .map_err(|e| HashSet::from([e.to_display(unifier).to_string()]))?;
                }
                ast::StmtKind::AnnAssign { target, annotation, value, .. } => {
-                    if let ast::ExprKind::Name { id: attr, .. } = &target.node {
+                    if let ExprKind::Name { id: attr, .. } = &target.node {
                        if defined_fields.insert(attr.to_string()) {
                            let dummy_field_type = unifier.get_dummy_var().ty;

@ -1305,7 +1481,7 @@ impl TopLevelComposer {
                                None => {
                                    // handle Kernel[T], KernelInvariant[T]
                                    let (annotation, mutable) = match &annotation.node {
-                                        ast::ExprKind::Subscript { value, slice, .. }
+                                        ExprKind::Subscript { value, slice, .. }
                                            if matches!(
                                                &value.node,
                                                ast::ExprKind::Name { id, .. } if id == &core_config.kernel_invariant_ann.into()
@ -1313,7 +1489,7 @@ impl TopLevelComposer {
                                        {
                                            (slice, false)
                                        }
-                                        ast::ExprKind::Subscript { value, slice, .. }
+                                        ExprKind::Subscript { value, slice, .. }
                                            if matches!(
                                                &value.node,
                                                ast::ExprKind::Name { id, .. } if core_config.kernel_ann.map_or(false, |c| id == &c.into())
@ -1331,13 +1507,13 @@ impl TopLevelComposer {
                                Some(boxed_expr) => {
                                    // Class attributes are set as immutable regardless
                                    let (annotation, _) = match &annotation.node {
-                                        ast::ExprKind::Subscript { slice, .. } => (slice, false),
+                                        ExprKind::Subscript { slice, .. } => (slice, false),
                                        _ if core_config.kernel_ann.is_none() => (annotation, false),
                                        _ => continue,
                                    };

                                    match &**boxed_expr {
-                                        ast::Located {location: _, custom: (), node: ast::ExprKind::Constant { value: v, kind: _ }} => {
+                                        ast::Located {location: _, custom: (), node: ExprKind::Constant { value: v, kind: _ }} => {
                                            // Restricting the types allowed to be defined as class attributes
                                            match v {
                                                ast::Constant::Bool(_) | ast::Constant::Str(_) | ast::Constant::Int(_) | ast::Constant::Float(_) => {}
@ -1604,7 +1780,6 @@ impl TopLevelComposer {
            }
        }

-        let mut errors = HashSet::new();
        let mut analyze = |i, def: &Arc<RwLock<TopLevelDef>>, ast: &Option<Stmt>| {
            let class_def = def.read();
            if let TopLevelDef::Class {
@ -1622,6 +1797,7 @@ impl TopLevelComposer {
                let self_type = get_type_from_type_annotation_kinds(
                    &def_list,
                    unifier,
+                    primitives_ty,
                    &make_self_type_annotation(type_vars, *object_id),
                    &mut None,
                )?;
@ -1638,21 +1814,25 @@ impl TopLevelComposer {
                                name: "msg".into(),
                                ty: string,
                                default_value: Some(SymbolValue::Str(String::new())),
+                                is_vararg: false,
                            },
                            FuncArg {
                                name: "param0".into(),
                                ty: int64,
                                default_value: Some(SymbolValue::I64(0)),
+                                is_vararg: false,
                            },
                            FuncArg {
                                name: "param1".into(),
                                ty: int64,
                                default_value: Some(SymbolValue::I64(0)),
+                                is_vararg: false,
                            },
                            FuncArg {
                                name: "param2".into(),
                                ty: int64,
                                default_value: Some(SymbolValue::I64(0)),
+                                is_vararg: false,
                            },
                        ],
                        ret: self_type,
@ -1719,7 +1899,12 @@ impl TopLevelComposer {
                        if *name != init_str_id {
                            unreachable!("must be init function here")
                        }
-                        let all_inited = Self::get_all_assigned_field(body.as_slice())?;
+
+                        let all_inited = Self::get_all_assigned_field(
+                            object_id.0,
+                            definition_ast_list,
+                            body.as_slice(),
+                        )?;
                        for (f, _, _) in fields {
                            if !all_inited.contains(f) {
                                return Err(HashSet::from([
@ -1737,6 +1922,8 @@ impl TopLevelComposer {
            }
            Ok(())
        };
+
+        let mut errors = HashSet::new();
        for (i, (def, ast)) in definition_ast_list.iter().enumerate().skip(self.builtin_num) {
            if ast.is_none() {
                continue;
@ -1774,19 +1961,20 @@ impl TopLevelComposer {
            if ast.is_none() {
                return Ok(());
            }
-            let mut function_def = def.write();
-            if let TopLevelDef::Function {
-                instance_to_stmt,
-                instance_to_symbol,
-                name,
-                simple_name,
-                signature,
-                resolver,
-                ..
-            } = &mut *function_def
-            {
-                let signature_ty_enum = unifier.get_ty(*signature);
-                let TypeEnum::TFunc(FunSignature { args, ret, vars }) = signature_ty_enum.as_ref()
+
+            let (name, simple_name, signature, resolver) = {
+                let function_def = def.read();
+                let TopLevelDef::Function { name, simple_name, signature, resolver, .. } =
+                    &*function_def
+                else {
+                    return Ok(());
+                };
+
+                (name.clone(), *simple_name, *signature, resolver.clone())
+            };
+
+            let signature_ty_enum = unifier.get_ty(signature);
+            let TypeEnum::TFunc(FunSignature { args, ret, vars, .. }) = signature_ty_enum.as_ref()
            else {
                unreachable!("must be typeenum::tfunc")
            };
@ -1803,7 +1991,11 @@ impl TopLevelComposer {

                    let ty_ann = make_self_type_annotation(type_vars, *class_id);
                    let self_ty = get_type_from_type_annotation_kinds(
-                            &def_list, unifier, &ty_ann, &mut None,
+                        &def_list,
+                        unifier,
+                        primitives_ty,
+                        &ty_ann,
+                        &mut None,
                    )?;
                    vars.extend(type_vars.iter().map(|ty| {
                        let TypeEnum::TVar { id, .. } = &*unifier.get_ty(*ty) else {
@ -1858,6 +2050,7 @@ impl TopLevelComposer {
                            name: a.name,
                            ty: unifier.subst(a.ty, &subst).unwrap_or(a.ty),
                            default_value: a.default_value.clone(),
+                            is_vararg: false,
                        })
                        .collect_vec()
                };
@ -1889,11 +2082,11 @@ impl TopLevelComposer {
                    })
                };
                let mut identifiers = {
-                        let mut result: HashSet<_> = HashSet::new();
+                    let mut result = HashMap::new();
                    if self_type.is_some() {
-                            result.insert("self".into());
+                        result.insert("self".into(), IdentifierInfo::default());
                    }
-                        result.extend(inst_args.iter().map(|x| x.name));
+                    result.extend(inst_args.iter().map(|x| (x.name, IdentifierInfo::default())));
                    result
                };
                let mut calls: HashMap<CodeLocation, CallId> = HashMap::new();
@ -1930,23 +2123,43 @@ impl TopLevelComposer {
                else {
                    unreachable!("must be function def ast")
                };
-                    if !decorator_list.is_empty()
-                        && matches!(&decorator_list[0].node,
-                            ast::ExprKind::Name{ id, .. } if id == &"extern".into())
-                    {
-                        instance_to_symbol.insert(String::new(), simple_name.to_string());
-                        continue;
-                    }
-                    if !decorator_list.is_empty()
-                        && matches!(&decorator_list[0].node,
-                            ast::ExprKind::Name{ id, .. } if id == &"rpc".into())
+
+                if !decorator_list.is_empty() {
+                    if matches!(&decorator_list[0].node, ExprKind::Name { id, .. } if id == &"extern".into())
                    {
+                        let TopLevelDef::Function { instance_to_symbol, .. } = &mut *def.write()
+                        else {
+                            unreachable!()
+                        };
                        instance_to_symbol.insert(String::new(), simple_name.to_string());
                        continue;
                    }

-                    let fun_body = body
-                        .into_iter()
+                    if matches!(&decorator_list[0].node, ExprKind::Name { id, .. } if id == &"rpc".into())
+                    {
+                        let TopLevelDef::Function { instance_to_symbol, .. } = &mut *def.write()
+                        else {
+                            unreachable!()
+                        };
+                        instance_to_symbol.insert(String::new(), simple_name.to_string());
+                        continue;
+                    }
+
+                    if let ExprKind::Call { func, .. } = &decorator_list[0].node {
+                        if matches!(&func.node, ExprKind::Name { id, .. } if id == &"rpc".into()) {
+                            let TopLevelDef::Function { instance_to_symbol, .. } =
+                                &mut *def.write()
+                            else {
+                                unreachable!()
+                            };
+                            instance_to_symbol.insert(String::new(), simple_name.to_string());
+                            continue;
+                        }
+                    }
+                }
+
+                let fun_body =
+                    body.into_iter()
                        .map(|b| inferencer.fold_stmt(b))
                        .collect::<Result<Vec<_>, _>>()?;

@ -2016,6 +2229,9 @@ impl TopLevelComposer {
                    )]));
                }

+                let TopLevelDef::Function { instance_to_stmt, .. } = &mut *def.write() else {
+                    unreachable!()
+                };
                instance_to_stmt.insert(
                    get_subst_key(
                        unifier,
@ -2031,10 +2247,10 @@ impl TopLevelComposer {
                    },
                );
            }
-            }

            Ok(())
        };
+
        for (id, (def, ast)) in self.definition_ast_list.iter().enumerate().skip(self.builtin_num) {
            if ast.is_none() {
                continue;
@ -2048,4 +2264,59 @@ impl TopLevelComposer {
        }
        Ok(())
    }
+
+    /// Step 6. Analyze and populate the types of global variables.
+    fn analyze_top_level_variables(&mut self) -> Result<(), HashSet<String>> {
+        let def_list = &self.definition_ast_list;
+        let temp_def_list = self.extract_def_list();
+        let unifier = &mut self.unifier;
+        let primitives_store = &self.primitives_ty;
+
+        let mut analyze = |variable_def: &Arc<RwLock<TopLevelDef>>| -> Result<_, HashSet<String>> {
+            let TopLevelDef::Variable { ty: dummy_ty, ty_decl, resolver, loc, .. } =
+                &*variable_def.read()
+            else {
+                // not top level variable def, skip
+                return Ok(());
+            };
+
+            let resolver = &**resolver.as_ref().unwrap();
+
+            if let Some(ty_decl) = ty_decl {
+                let ty_annotation = parse_ast_to_type_annotation_kinds(
+                    resolver,
+                    &temp_def_list,
+                    unifier,
+                    primitives_store,
+                    ty_decl,
+                    HashMap::new(),
+                )?;
+                let ty_from_ty_annotation = get_type_from_type_annotation_kinds(
+                    &temp_def_list,
+                    unifier,
+                    primitives_store,
+                    &ty_annotation,
+                    &mut None,
+                )?;
+
+                unifier.unify(*dummy_ty, ty_from_ty_annotation).map_err(|e| {
+                    HashSet::from([e.at(Some(loc.unwrap())).to_display(unifier).to_string()])
+                })?;
+            }
+
+            Ok(())
+        };
+
+        let mut errors = HashSet::new();
+        for (variable_def, _) in def_list.iter().skip(self.builtin_num) {
+            if let Err(e) = analyze(variable_def) {
+                errors.extend(e);
+            }
+        }
+        if !errors.is_empty() {
+            return Err(errors);
+        }
+
+        Ok(())
+    }
 }
--- a/nac3core/src/toplevel/helper.rs
+++ b/nac3core/src/toplevel/helper.rs
@ -1,13 +1,15 @@
 use std::convert::TryInto;

-use crate::symbol_resolver::SymbolValue;
-use crate::toplevel::numpy::unpack_ndarray_var_tys;
-use crate::typecheck::typedef::{into_var_map, iter_type_vars, Mapping, TypeVarId, VarMap};
-use nac3parser::ast::{Constant, Location};
 use strum::IntoEnumIterator;
 use strum_macros::EnumIter;

-use super::*;
+use nac3parser::ast::{Constant, ExprKind, Location};
+
+use super::{numpy::unpack_ndarray_var_tys, *};
+use crate::{
+    symbol_resolver::SymbolValue,
+    typecheck::typedef::{into_var_map, iter_type_vars, Mapping, TypeVarId, VarMap},
+};

 /// All primitive types and functions in nac3core.
 #[derive(Clone, Copy, Debug, EnumIter, PartialEq, Eq)]
@ -27,17 +29,22 @@ pub enum PrimDef {
    List,
    NDArray,

-    // Member Functions
-    OptionIsSome,
-    OptionIsNone,
-    OptionUnwrap,
-    NDArrayCopy,
-    NDArrayFill,
-    FunInt32,
-    FunInt64,
-    FunUInt32,
-    FunUInt64,
-    FunFloat,
+    // Option methods
+    FunOptionIsSome,
+    FunOptionIsNone,
+    FunOptionUnwrap,
+
+    // Option-related functions
+    FunSome,
+
+    // NDArray methods
+    FunNDArrayCopy,
+    FunNDArrayFill,
+
+    // Range methods
+    FunRangeInit,
+
+    // NumPy factory functions
    FunNpNDArray,
    FunNpEmpty,
    FunNpZeros,
@ -46,26 +53,17 @@ pub enum PrimDef {
    FunNpArray,
    FunNpEye,
    FunNpIdentity,
-    FunRound,
-    FunRound64,
+
+    // Miscellaneous NumPy & SciPy functions
    FunNpRound,
-    FunRangeInit,
-    FunStr,
-    FunBool,
-    FunFloor,
-    FunFloor64,
    FunNpFloor,
-    FunCeil,
-    FunCeil64,
    FunNpCeil,
-    FunLen,
-    FunMin,
    FunNpMin,
    FunNpMinimum,
-    FunMax,
+    FunNpArgmin,
    FunNpMax,
    FunNpMaximum,
-    FunAbs,
+    FunNpArgmax,
    FunNpIsNan,
    FunNpIsInf,
    FunNpSin,
@ -103,15 +101,46 @@ pub enum PrimDef {
    FunNpLdExp,
    FunNpHypot,
    FunNpNextAfter,
+    FunNpTranspose,
+    FunNpReshape,

-    // Top-Level Functions
-    FunSome,
+    // Linalg functions
+    FunNpDot,
+    FunNpLinalgCholesky,
+    FunNpLinalgQr,
+    FunNpLinalgSvd,
+    FunNpLinalgInv,
+    FunNpLinalgPinv,
+    FunNpLinalgMatrixPower,
+    FunNpLinalgDet,
+    FunSpLinalgLu,
+    FunSpLinalgSchur,
+    FunSpLinalgHessenberg,
+
+    // Miscellaneous Python & NAC3 functions
+    FunInt32,
+    FunInt64,
+    FunUInt32,
+    FunUInt64,
+    FunFloat,
+    FunRound,
+    FunRound64,
+    FunStr,
+    FunBool,
+    FunFloor,
+    FunFloor64,
+    FunCeil,
+    FunCeil64,
+    FunLen,
+    FunMin,
+    FunMax,
+    FunAbs,
 }

 /// Associated details of a [`PrimDef`]
 pub enum PrimDefDetails {
    PrimFunction { name: &'static str, simple_name: &'static str },
-    PrimClass { name: &'static str },
+    PrimClass { name: &'static str, get_ty_fn: fn(&PrimitiveStore) -> Type },
 }

 impl PrimDef {
@ -153,15 +182,17 @@ impl PrimDef {
    #[must_use]
    pub fn name(&self) -> &'static str {
        match self.details() {
-            PrimDefDetails::PrimFunction { name, .. } | PrimDefDetails::PrimClass { name } => name,
+            PrimDefDetails::PrimFunction { name, .. } | PrimDefDetails::PrimClass { name, .. } => {
+                name
+            }
        }
    }

    /// Get the associated details of this [`PrimDef`]
    #[must_use]
    pub fn details(self) -> PrimDefDetails {
-        fn class(name: &'static str) -> PrimDefDetails {
-            PrimDefDetails::PrimClass { name }
+        fn class(name: &'static str, get_ty_fn: fn(&PrimitiveStore) -> Type) -> PrimDefDetails {
+            PrimDefDetails::PrimClass { name, get_ty_fn }
        }

        fn fun(name: &'static str, simple_name: Option<&'static str>) -> PrimDefDetails {
@ -169,29 +200,37 @@ impl PrimDef {
        }

        match self {
-            PrimDef::Int32 => class("int32"),
-            PrimDef::Int64 => class("int64"),
-            PrimDef::Float => class("float"),
-            PrimDef::Bool => class("bool"),
-            PrimDef::None => class("none"),
-            PrimDef::Range => class("range"),
-            PrimDef::Str => class("str"),
-            PrimDef::Exception => class("Exception"),
-            PrimDef::UInt32 => class("uint32"),
-            PrimDef::UInt64 => class("uint64"),
-            PrimDef::Option => class("Option"),
-            PrimDef::OptionIsSome => fun("Option.is_some", Some("is_some")),
-            PrimDef::OptionIsNone => fun("Option.is_none", Some("is_none")),
-            PrimDef::OptionUnwrap => fun("Option.unwrap", Some("unwrap")),
-            PrimDef::List => class("list"),
-            PrimDef::NDArray => class("ndarray"),
-            PrimDef::NDArrayCopy => fun("ndarray.copy", Some("copy")),
-            PrimDef::NDArrayFill => fun("ndarray.fill", Some("fill")),
-            PrimDef::FunInt32 => fun("int32", None),
-            PrimDef::FunInt64 => fun("int64", None),
-            PrimDef::FunUInt32 => fun("uint32", None),
-            PrimDef::FunUInt64 => fun("uint64", None),
-            PrimDef::FunFloat => fun("float", None),
+            // Classes
+            PrimDef::Int32 => class("int32", |primitives| primitives.int32),
+            PrimDef::Int64 => class("int64", |primitives| primitives.int64),
+            PrimDef::Float => class("float", |primitives| primitives.float),
+            PrimDef::Bool => class("bool", |primitives| primitives.bool),
+            PrimDef::None => class("none", |primitives| primitives.none),
+            PrimDef::Range => class("range", |primitives| primitives.range),
+            PrimDef::Str => class("str", |primitives| primitives.str),
+            PrimDef::Exception => class("Exception", |primitives| primitives.exception),
+            PrimDef::UInt32 => class("uint32", |primitives| primitives.uint32),
+            PrimDef::UInt64 => class("uint64", |primitives| primitives.uint64),
+            PrimDef::Option => class("Option", |primitives| primitives.option),
+            PrimDef::List => class("list", |primitives| primitives.list),
+            PrimDef::NDArray => class("ndarray", |primitives| primitives.ndarray),
+
+            // Option methods
+            PrimDef::FunOptionIsSome => fun("Option.is_some", Some("is_some")),
+            PrimDef::FunOptionIsNone => fun("Option.is_none", Some("is_none")),
+            PrimDef::FunOptionUnwrap => fun("Option.unwrap", Some("unwrap")),
+
+            // Option-related functions
+            PrimDef::FunSome => fun("Some", None),
+
+            // NDArray methods
+            PrimDef::FunNDArrayCopy => fun("ndarray.copy", Some("copy")),
+            PrimDef::FunNDArrayFill => fun("ndarray.fill", Some("fill")),
+
+            // Range methods
+            PrimDef::FunRangeInit => fun("range.__init__", Some("__init__")),
+
+            // NumPy factory functions
            PrimDef::FunNpNDArray => fun("np_ndarray", None),
            PrimDef::FunNpEmpty => fun("np_empty", None),
            PrimDef::FunNpZeros => fun("np_zeros", None),
@ -200,26 +239,17 @@ impl PrimDef {
            PrimDef::FunNpArray => fun("np_array", None),
            PrimDef::FunNpEye => fun("np_eye", None),
            PrimDef::FunNpIdentity => fun("np_identity", None),
-            PrimDef::FunRound => fun("round", None),
-            PrimDef::FunRound64 => fun("round64", None),
+
+            // Miscellaneous NumPy & SciPy functions
            PrimDef::FunNpRound => fun("np_round", None),
-            PrimDef::FunRangeInit => fun("range.__init__", Some("__init__")),
-            PrimDef::FunStr => fun("str", None),
-            PrimDef::FunBool => fun("bool", None),
-            PrimDef::FunFloor => fun("floor", None),
-            PrimDef::FunFloor64 => fun("floor64", None),
            PrimDef::FunNpFloor => fun("np_floor", None),
-            PrimDef::FunCeil => fun("ceil", None),
-            PrimDef::FunCeil64 => fun("ceil64", None),
            PrimDef::FunNpCeil => fun("np_ceil", None),
-            PrimDef::FunLen => fun("len", None),
-            PrimDef::FunMin => fun("min", None),
            PrimDef::FunNpMin => fun("np_min", None),
            PrimDef::FunNpMinimum => fun("np_minimum", None),
-            PrimDef::FunMax => fun("max", None),
+            PrimDef::FunNpArgmin => fun("np_argmin", None),
            PrimDef::FunNpMax => fun("np_max", None),
            PrimDef::FunNpMaximum => fun("np_maximum", None),
-            PrimDef::FunAbs => fun("abs", None),
+            PrimDef::FunNpArgmax => fun("np_argmax", None),
            PrimDef::FunNpIsNan => fun("np_isnan", None),
            PrimDef::FunNpIsInf => fun("np_isinf", None),
            PrimDef::FunNpSin => fun("np_sin", None),
@ -257,7 +287,40 @@ impl PrimDef {
            PrimDef::FunNpLdExp => fun("np_ldexp", None),
            PrimDef::FunNpHypot => fun("np_hypot", None),
            PrimDef::FunNpNextAfter => fun("np_nextafter", None),
-            PrimDef::FunSome => fun("Some", None),
+            PrimDef::FunNpTranspose => fun("np_transpose", None),
+            PrimDef::FunNpReshape => fun("np_reshape", None),
+
+            // Linalg functions
+            PrimDef::FunNpDot => fun("np_dot", None),
+            PrimDef::FunNpLinalgCholesky => fun("np_linalg_cholesky", None),
+            PrimDef::FunNpLinalgQr => fun("np_linalg_qr", None),
+            PrimDef::FunNpLinalgSvd => fun("np_linalg_svd", None),
+            PrimDef::FunNpLinalgInv => fun("np_linalg_inv", None),
+            PrimDef::FunNpLinalgPinv => fun("np_linalg_pinv", None),
+            PrimDef::FunNpLinalgMatrixPower => fun("np_linalg_matrix_power", None),
+            PrimDef::FunNpLinalgDet => fun("np_linalg_det", None),
+            PrimDef::FunSpLinalgLu => fun("sp_linalg_lu", None),
+            PrimDef::FunSpLinalgSchur => fun("sp_linalg_schur", None),
+            PrimDef::FunSpLinalgHessenberg => fun("sp_linalg_hessenberg", None),
+
+            // Miscellaneous Python & NAC3 functions
+            PrimDef::FunInt32 => fun("int32", None),
+            PrimDef::FunInt64 => fun("int64", None),
+            PrimDef::FunUInt32 => fun("uint32", None),
+            PrimDef::FunUInt64 => fun("uint64", None),
+            PrimDef::FunFloat => fun("float", None),
+            PrimDef::FunRound => fun("round", None),
+            PrimDef::FunRound64 => fun("round64", None),
+            PrimDef::FunStr => fun("str", None),
+            PrimDef::FunBool => fun("bool", None),
+            PrimDef::FunFloor => fun("floor", None),
+            PrimDef::FunFloor64 => fun("floor64", None),
+            PrimDef::FunCeil => fun("ceil", None),
+            PrimDef::FunCeil64 => fun("ceil64", None),
+            PrimDef::FunLen => fun("len", None),
+            PrimDef::FunMin => fun("min", None),
+            PrimDef::FunMax => fun("max", None),
+            PrimDef::FunAbs => fun("abs", None),
        }
    }
 }
@ -326,6 +389,9 @@ impl TopLevelDef {
                    r
                }
            ),
+            TopLevelDef::Variable { name, ty, .. } => {
+                format!("Variable {{ name: {name:?}, ty: {:?} }}", unifier.stringify(*ty),)
+            }
        }
    }
 }
@ -408,9 +474,9 @@ impl TopLevelComposer {
        let option = unifier.add_ty(TypeEnum::TObj {
            obj_id: PrimDef::Option.id(),
            fields: vec![
-                (PrimDef::OptionIsSome.simple_name().into(), (is_some_type_fun_ty, true)),
-                (PrimDef::OptionIsNone.simple_name().into(), (is_some_type_fun_ty, true)),
-                (PrimDef::OptionUnwrap.simple_name().into(), (unwrap_fun_ty, true)),
+                (PrimDef::FunOptionIsSome.simple_name().into(), (is_some_type_fun_ty, true)),
+                (PrimDef::FunOptionIsNone.simple_name().into(), (is_some_type_fun_ty, true)),
+                (PrimDef::FunOptionUnwrap.simple_name().into(), (unwrap_fun_ty, true)),
            ]
            .into_iter()
            .collect::<HashMap<_, _>>(),
@ -444,6 +510,7 @@ impl TopLevelComposer {
                name: "value".into(),
                ty: ndarray_dtype_tvar.ty,
                default_value: None,
+                is_vararg: false,
            }],
            ret: none,
            vars: into_var_map([ndarray_dtype_tvar, ndarray_ndims_tvar]),
@ -451,8 +518,8 @@ impl TopLevelComposer {
        let ndarray = unifier.add_ty(TypeEnum::TObj {
            obj_id: PrimDef::NDArray.id(),
            fields: Mapping::from([
-                (PrimDef::NDArrayCopy.simple_name().into(), (ndarray_copy_fun_ty, true)),
-                (PrimDef::NDArrayFill.simple_name().into(), (ndarray_fill_fun_ty, true)),
+                (PrimDef::FunNDArrayCopy.simple_name().into(), (ndarray_copy_fun_ty, true)),
+                (PrimDef::FunNDArrayFill.simple_name().into(), (ndarray_fill_fun_ty, true)),
            ]),
            params: into_var_map([ndarray_dtype_tvar, ndarray_ndims_tvar]),
        });
@ -526,6 +593,18 @@ impl TopLevelComposer {
        }
    }

+    #[must_use]
+    pub fn make_top_level_variable_def(
+        name: String,
+        simple_name: StrRef,
+        ty: Type,
+        ty_decl: Option<Expr>,
+        resolver: Option<Arc<dyn SymbolResolver + Send + Sync>>,
+        loc: Option<Location>,
+    ) -> TopLevelDef {
+        TopLevelDef::Variable { name, simple_name, ty, ty_decl, resolver, loc }
+    }
+
    #[must_use]
    pub fn make_class_method_name(mut class_name: String, method_name: &str) -> String {
        class_name.push('.');
@ -671,7 +750,16 @@ impl TopLevelComposer {
        )
    }

-    pub fn get_all_assigned_field(stmts: &[Stmt<()>]) -> Result<HashSet<StrRef>, HashSet<String>> {
+    /// This function returns the fields that have been initialized in the `__init__` function of a class
+    /// The function takes as input:
+    ///  * `class_id`: The `object_id` of the class whose function is being evaluated (check `TopLevelDef::Class`)
+    ///  * `definition_ast_list`: A list of ast definitions and statements defined in `TopLevelComposer`
+    ///  * `stmts`: The body of function being parsed. Each statment is analyzed to check varaible initialization statements
+    pub fn get_all_assigned_field(
+        class_id: usize,
+        definition_ast_list: &Vec<DefAst>,
+        stmts: &[Stmt<()>],
+    ) -> Result<HashSet<StrRef>, HashSet<String>> {
        let mut result = HashSet::new();
        for s in stmts {
            match &s.node {
@ -707,30 +795,138 @@ impl TopLevelComposer {
                // TODO: do not check for For and While?
                ast::StmtKind::For { body, orelse, .. }
                | ast::StmtKind::While { body, orelse, .. } => {
-                    result.extend(Self::get_all_assigned_field(body.as_slice())?);
-                    result.extend(Self::get_all_assigned_field(orelse.as_slice())?);
+                    result.extend(Self::get_all_assigned_field(
+                        class_id,
+                        definition_ast_list,
+                        body.as_slice(),
+                    )?);
+                    result.extend(Self::get_all_assigned_field(
+                        class_id,
+                        definition_ast_list,
+                        orelse.as_slice(),
+                    )?);
                }
                ast::StmtKind::If { body, orelse, .. } => {
-                    let inited_for_sure = Self::get_all_assigned_field(body.as_slice())?
-                        .intersection(&Self::get_all_assigned_field(orelse.as_slice())?)
+                    let inited_for_sure = Self::get_all_assigned_field(
+                        class_id,
+                        definition_ast_list,
+                        body.as_slice(),
+                    )?
+                    .intersection(&Self::get_all_assigned_field(
+                        class_id,
+                        definition_ast_list,
+                        orelse.as_slice(),
+                    )?)
                    .copied()
                    .collect::<HashSet<_>>();
                    result.extend(inited_for_sure);
                }
                ast::StmtKind::Try { body, orelse, finalbody, .. } => {
-                    let inited_for_sure = Self::get_all_assigned_field(body.as_slice())?
-                        .intersection(&Self::get_all_assigned_field(orelse.as_slice())?)
+                    let inited_for_sure = Self::get_all_assigned_field(
+                        class_id,
+                        definition_ast_list,
+                        body.as_slice(),
+                    )?
+                    .intersection(&Self::get_all_assigned_field(
+                        class_id,
+                        definition_ast_list,
+                        orelse.as_slice(),
+                    )?)
                    .copied()
                    .collect::<HashSet<_>>();
                    result.extend(inited_for_sure);
-                    result.extend(Self::get_all_assigned_field(finalbody.as_slice())?);
+                    result.extend(Self::get_all_assigned_field(
+                        class_id,
+                        definition_ast_list,
+                        finalbody.as_slice(),
+                    )?);
                }
                ast::StmtKind::With { body, .. } => {
-                    result.extend(Self::get_all_assigned_field(body.as_slice())?);
+                    result.extend(Self::get_all_assigned_field(
+                        class_id,
+                        definition_ast_list,
+                        body.as_slice(),
+                    )?);
+                }
+                // Variables Initialized in function calls
+                ast::StmtKind::Expr { value, .. } => {
+                    let ExprKind::Call { func, .. } = &value.node else {
+                        continue;
+                    };
+                    let ExprKind::Attribute { value, attr, .. } = &func.node else {
+                        continue;
+                    };
+                    let ExprKind::Name { id, .. } = &value.node else {
+                        continue;
+                    };
+                    // Need to consider the two cases:
+                    //  Case 1) Call to class function i.e. id = `self`
+                    //  Case 2) Call to class ancestor function i.e. id = ancestor_name
+                    // We leave checking whether function in case 2 belonged to class ancestor or not to type checker
+                    //
+                    // According to current handling of `self`, function definition are fixed and do not change regardless
+                    // of which object is passed as `self` i.e. virtual polymorphism is not supported
+                    // Therefore, we change class id for case 2 to reflect behavior of our compiler
+
+                    let class_name = if *id == "self".into() {
+                        let ast::StmtKind::ClassDef { name, .. } =
+                            &definition_ast_list[class_id].1.as_ref().unwrap().node
+                        else {
+                            unreachable!()
+                        };
+                        name
+                    } else {
+                        id
+                    };
+
+                    let parent_method = definition_ast_list.iter().find_map(|def| {
+                        let (
+                            class_def,
+                            Some(ast::Located {
+                                node: ast::StmtKind::ClassDef { name, body, .. },
+                                ..
+                            }),
+                        ) = &def
+                        else {
+                            return None;
+                        };
+                        let TopLevelDef::Class { object_id: class_id, .. } = &*class_def.read()
+                        else {
+                            unreachable!()
+                        };
+
+                        if name == class_name {
+                            body.iter().find_map(|m| {
+                                let ast::StmtKind::FunctionDef { name, body, .. } = &m.node else {
+                                    return None;
+                                };
+                                if *name == *attr {
+                                    return Some((body.clone(), class_id.0));
+                                }
+                                None
+                            })
+                        } else {
+                            None
+                        }
+                    });
+
+                    // If method body is none then method does not exist
+                    if let Some((method_body, class_id)) = parent_method {
+                        result.extend(Self::get_all_assigned_field(
+                            class_id,
+                            definition_ast_list,
+                            method_body.as_slice(),
+                        )?);
+                    } else {
+                        return Err(HashSet::from([format!(
+                            "{}.{} not found in class {class_name} at {}",
+                            *id, *attr, value.location
+                        )]));
+                    }
                }
                ast::StmtKind::Pass { .. }
                | ast::StmtKind::Assert { .. }
-                | ast::StmtKind::Expr { .. } => {}
+                | ast::StmtKind::AnnAssign { .. } => {}

                _ => {
                    unimplemented!()
--- a/nac3core/src/toplevel/mod.rs
+++ b/nac3core/src/toplevel/mod.rs
@ -6,36 +6,36 @@ use std::{
    sync::Arc,
 };

-use super::codegen::CodeGenContext;
-use super::typecheck::type_inferencer::PrimitiveStore;
-use super::typecheck::typedef::{
-    FunSignature, FuncArg, SharedUnifier, Type, TypeEnum, Unifier, VarMap,
-};
-use crate::{
-    codegen::CodeGenerator,
-    symbol_resolver::{SymbolResolver, ValueEnum},
-    typecheck::{
-        type_inferencer::CodeLocation,
-        typedef::{CallId, TypeVarId},
-    },
-};
 use inkwell::values::BasicValueEnum;
 use itertools::Itertools;
-use nac3parser::ast::{self, Location, Stmt, StrRef};
 use parking_lot::RwLock;

-#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Hash, Debug)]
-pub struct DefinitionId(pub usize);
+use nac3parser::ast::{self, Expr, Location, Stmt, StrRef};
+
+use crate::{
+    codegen::{CodeGenContext, CodeGenerator},
+    symbol_resolver::{SymbolResolver, ValueEnum},
+    typecheck::{
+        type_inferencer::{CodeLocation, PrimitiveStore},
+        typedef::{
+            CallId, FunSignature, FuncArg, SharedUnifier, Type, TypeEnum, TypeVarId, Unifier,
+            VarMap,
+        },
+    },
+};
+use composer::*;
+use type_annotation::*;

 pub mod builtins;
 pub mod composer;
 pub mod helper;
 pub mod numpy;
-pub mod type_annotation;
-use composer::*;
-use type_annotation::*;
 #[cfg(test)]
 mod test;
+pub mod type_annotation;
+
+#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Hash, Debug)]
+pub struct DefinitionId(pub usize);

 type GenCallCallback = dyn for<'ctx, 'a> Fn(
        &mut CodeGenContext<'ctx, 'a>,
@ -148,6 +148,25 @@ pub enum TopLevelDef {
        /// Definition location.
        loc: Option<Location>,
    },
+    Variable {
+        /// Qualified name of the global variable, should be unique globally.
+        name: String,
+
+        /// Simple name, the same as in method/function definition.
+        simple_name: StrRef,
+
+        /// Type of the global variable.
+        ty: Type,
+
+        /// The declared type of the global variable, or [`None`] if no type annotation is provided.
+        ty_decl: Option<Expr>,
+
+        /// Symbol resolver of the module defined the class.
+        resolver: Option<Arc<dyn SymbolResolver + Send + Sync>>,
+
+        /// Definition location.
+        loc: Option<Location>,
+    },
 }

 pub struct TopLevelContext {
--- a/nac3core/src/toplevel/numpy.rs
+++ b/nac3core/src/toplevel/numpy.rs
@ -1,11 +1,10 @@
-use crate::{
-    toplevel::helper::PrimDef,
-    typecheck::{
+use itertools::Itertools;
+
+use super::helper::PrimDef;
+use crate::typecheck::{
    type_inferencer::PrimitiveStore,
    typedef::{Type, TypeEnum, TypeVarId, Unifier, VarMap},
-    },
 };
-use itertools::Itertools;

 /// Creates a `ndarray` [`Type`] with the given type arguments.
 ///
--- a/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__generic_class.snap
+++ b/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__generic_class.snap
@ -5,7 +5,7 @@ expression: res_vec
 [
    "Class {\nname: \"Generic_A\",\nancestors: [\"Generic_A[V]\", \"B\"],\nfields: [\"aa\", \"a\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"foo\", \"fn[[b:T], none]\"), (\"fun\", \"fn[[a:int32], V]\")],\ntype_vars: [\"V\"]\n}\n",
    "Function {\nname: \"Generic_A.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
-    "Function {\nname: \"Generic_A.fun\",\nsig: \"fn[[a:int32], V]\",\nvar_id: [TypeVarId(245)]\n}\n",
+    "Function {\nname: \"Generic_A.fun\",\nsig: \"fn[[a:int32], V]\",\nvar_id: [TypeVarId(241)]\n}\n",
    "Class {\nname: \"B\",\nancestors: [\"B\"],\nfields: [\"aa\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"foo\", \"fn[[b:T], none]\")],\ntype_vars: []\n}\n",
    "Function {\nname: \"B.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"B.foo\",\nsig: \"fn[[b:T], none]\",\nvar_id: []\n}\n",
--- a/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__inheritance_override.snap
+++ b/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__inheritance_override.snap
@ -7,7 +7,7 @@ expression: res_vec
    "Function {\nname: \"A.__init__\",\nsig: \"fn[[t:T], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"A.fun\",\nsig: \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\",\nvar_id: []\n}\n",
    "Function {\nname: \"A.foo\",\nsig: \"fn[[c:C], none]\",\nvar_id: []\n}\n",
-    "Class {\nname: \"B\",\nancestors: [\"B[typevar234]\", \"A[float]\"],\nfields: [\"a\", \"b\", \"c\", \"d\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\"), (\"foo\", \"fn[[c:C], none]\")],\ntype_vars: [\"typevar234\"]\n}\n",
+    "Class {\nname: \"B\",\nancestors: [\"B[typevar230]\", \"A[float]\"],\nfields: [\"a\", \"b\", \"c\", \"d\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\"), (\"foo\", \"fn[[c:C], none]\")],\ntype_vars: [\"typevar230\"]\n}\n",
    "Function {\nname: \"B.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"B.fun\",\nsig: \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\",\nvar_id: []\n}\n",
    "Class {\nname: \"C\",\nancestors: [\"C\", \"B[bool]\", \"A[float]\"],\nfields: [\"a\", \"b\", \"c\", \"d\", \"e\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\"), (\"foo\", \"fn[[c:C], none]\")],\ntype_vars: []\n}\n",
--- a/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__list_tuple_generic.snap
+++ b/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__list_tuple_generic.snap
@ -5,8 +5,8 @@ expression: res_vec
 [
    "Function {\nname: \"foo\",\nsig: \"fn[[a:list[int32], b:tuple[T, float]], A[B, bool]]\",\nvar_id: []\n}\n",
    "Class {\nname: \"A\",\nancestors: [\"A[T, V]\"],\nfields: [\"a\", \"b\"],\nmethods: [(\"__init__\", \"fn[[v:V], none]\"), (\"fun\", \"fn[[a:T], V]\")],\ntype_vars: [\"T\", \"V\"]\n}\n",
-    "Function {\nname: \"A.__init__\",\nsig: \"fn[[v:V], none]\",\nvar_id: [TypeVarId(247)]\n}\n",
-    "Function {\nname: \"A.fun\",\nsig: \"fn[[a:T], V]\",\nvar_id: [TypeVarId(252)]\n}\n",
+    "Function {\nname: \"A.__init__\",\nsig: \"fn[[v:V], none]\",\nvar_id: [TypeVarId(243)]\n}\n",
+    "Function {\nname: \"A.fun\",\nsig: \"fn[[a:T], V]\",\nvar_id: [TypeVarId(248)]\n}\n",
    "Function {\nname: \"gfun\",\nsig: \"fn[[a:A[list[float], int32]], none]\",\nvar_id: []\n}\n",
    "Class {\nname: \"B\",\nancestors: [\"B\"],\nfields: [],\nmethods: [(\"__init__\", \"fn[[], none]\")],\ntype_vars: []\n}\n",
    "Function {\nname: \"B.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
--- a/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__self1.snap
+++ b/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__self1.snap
@ -3,7 +3,7 @@ source: nac3core/src/toplevel/test.rs
 expression: res_vec
 ---
 [
-    "Class {\nname: \"A\",\nancestors: [\"A[typevar233, typevar234]\"],\nfields: [\"a\", \"b\"],\nmethods: [(\"__init__\", \"fn[[a:A[float, bool], b:B], none]\"), (\"fun\", \"fn[[a:A[float, bool]], A[bool, int32]]\")],\ntype_vars: [\"typevar233\", \"typevar234\"]\n}\n",
+    "Class {\nname: \"A\",\nancestors: [\"A[typevar229, typevar230]\"],\nfields: [\"a\", \"b\"],\nmethods: [(\"__init__\", \"fn[[a:A[float, bool], b:B], none]\"), (\"fun\", \"fn[[a:A[float, bool]], A[bool, int32]]\")],\ntype_vars: [\"typevar229\", \"typevar230\"]\n}\n",
    "Function {\nname: \"A.__init__\",\nsig: \"fn[[a:A[float, bool], b:B], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"A.fun\",\nsig: \"fn[[a:A[float, bool]], A[bool, int32]]\",\nvar_id: []\n}\n",
    "Class {\nname: \"B\",\nancestors: [\"B\", \"A[int64, bool]\"],\nfields: [\"a\", \"b\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[a:A[float, bool]], A[bool, int32]]\"), (\"foo\", \"fn[[b:B], B]\"), (\"bar\", \"fn[[a:A[list[B], int32]], tuple[A[virtual[A[B, int32]], bool], B]]\")],\ntype_vars: []\n}\n",
--- a/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__simple_class_compose.snap
+++ b/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__simple_class_compose.snap
@ -6,12 +6,12 @@ expression: res_vec
    "Class {\nname: \"A\",\nancestors: [\"A\"],\nfields: [\"a\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[b:B], none]\"), (\"foo\", \"fn[[a:T, b:V], none]\")],\ntype_vars: []\n}\n",
    "Function {\nname: \"A.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"A.fun\",\nsig: \"fn[[b:B], none]\",\nvar_id: []\n}\n",
-    "Function {\nname: \"A.foo\",\nsig: \"fn[[a:T, b:V], none]\",\nvar_id: [TypeVarId(253)]\n}\n",
+    "Function {\nname: \"A.foo\",\nsig: \"fn[[a:T, b:V], none]\",\nvar_id: [TypeVarId(249)]\n}\n",
    "Class {\nname: \"B\",\nancestors: [\"B\", \"C\", \"A\"],\nfields: [\"a\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[b:B], none]\"), (\"foo\", \"fn[[a:T, b:V], none]\")],\ntype_vars: []\n}\n",
    "Function {\nname: \"B.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
    "Class {\nname: \"C\",\nancestors: [\"C\", \"A\"],\nfields: [\"a\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[b:B], none]\"), (\"foo\", \"fn[[a:T, b:V], none]\")],\ntype_vars: []\n}\n",
    "Function {\nname: \"C.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"C.fun\",\nsig: \"fn[[b:B], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"foo\",\nsig: \"fn[[a:A], none]\",\nvar_id: []\n}\n",
-    "Function {\nname: \"ff\",\nsig: \"fn[[a:T], V]\",\nvar_id: [TypeVarId(261)]\n}\n",
+    "Function {\nname: \"ff\",\nsig: \"fn[[a:T], V]\",\nvar_id: [TypeVarId(257)]\n}\n",
 ]
--- a/nac3core/src/toplevel/test.rs
+++ b/nac3core/src/toplevel/test.rs
@ -1,21 +1,23 @@
-use super::*;
-use crate::toplevel::helper::PrimDef;
-use crate::typecheck::typedef::into_var_map;
+use std::{collections::HashMap, sync::Arc};
+
+use indoc::indoc;
+use parking_lot::Mutex;
+use test_case::test_case;
+
+use nac3parser::{
+    ast::{fold::Fold, FileName},
+    parser::parse_program,
+};
+
+use super::{helper::PrimDef, DefinitionId, *};
 use crate::{
    codegen::CodeGenContext,
    symbol_resolver::{SymbolResolver, ValueEnum},
-    toplevel::DefinitionId,
    typecheck::{
        type_inferencer::PrimitiveStore,
-        typedef::{Type, Unifier},
+        typedef::{into_var_map, Type, Unifier},
    },
 };
-use indoc::indoc;
-use nac3parser::ast::FileName;
-use nac3parser::{ast::fold::Fold, parser::parse_program};
-use parking_lot::Mutex;
-use std::{collections::HashMap, sync::Arc};
-use test_case::test_case;

 struct ResolverInternal {
    id_to_type: Mutex<HashMap<StrRef, Type>>,
@ -62,6 +64,7 @@ impl SymbolResolver for Resolver {
        &self,
        _: StrRef,
        _: &mut CodeGenContext<'ctx, '_>,
+        _: &mut dyn CodeGenerator,
    ) -> Option<ValueEnum<'ctx>> {
        unimplemented!()
    }
@ -117,7 +120,8 @@ impl SymbolResolver for Resolver {
    "register"
 )]
 fn test_simple_register(source: Vec<&str>) {
-    let mut composer = TopLevelComposer::new(Vec::new(), ComposerConfig::default(), 64).0;
+    let mut composer =
+        TopLevelComposer::new(Vec::new(), Vec::new(), ComposerConfig::default(), 64).0;

    for s in source {
        let ast = parse_program(s, FileName::default()).unwrap();
@ -137,7 +141,8 @@ fn test_simple_register(source: Vec<&str>) {
    "register"
 )]
 fn test_simple_register_without_constructor(source: &str) {
-    let mut composer = TopLevelComposer::new(Vec::new(), ComposerConfig::default(), 64).0;
+    let mut composer =
+        TopLevelComposer::new(Vec::new(), Vec::new(), ComposerConfig::default(), 64).0;
    let ast = parse_program(source, FileName::default()).unwrap();
    let ast = ast[0].clone();
    composer.register_top_level(ast, None, "", true).unwrap();
@ -171,7 +176,8 @@ fn test_simple_register_without_constructor(source: &str) {
    "function compose"
 )]
 fn test_simple_function_analyze(source: &[&str], tys: &[&str], names: &[&str]) {
-    let mut composer = TopLevelComposer::new(Vec::new(), ComposerConfig::default(), 64).0;
+    let mut composer =
+        TopLevelComposer::new(Vec::new(), Vec::new(), ComposerConfig::default(), 64).0;

    let internal_resolver = Arc::new(ResolverInternal {
        id_to_def: Mutex::default(),
@ -519,7 +525,8 @@ fn test_simple_function_analyze(source: &[&str], tys: &[&str], names: &[&str]) {
 )]
 fn test_analyze(source: &[&str], res: &[&str]) {
    let print = false;
-    let mut composer = TopLevelComposer::new(Vec::new(), ComposerConfig::default(), 64).0;
+    let mut composer =
+        TopLevelComposer::new(Vec::new(), Vec::new(), ComposerConfig::default(), 64).0;

    let internal_resolver = make_internal_resolver_with_tvar(
        vec![
@ -696,7 +703,8 @@ fn test_analyze(source: &[&str], res: &[&str]) {
 )]
 fn test_inference(source: Vec<&str>, res: &[&str]) {
    let print = true;
-    let mut composer = TopLevelComposer::new(Vec::new(), ComposerConfig::default(), 64).0;
+    let mut composer =
+        TopLevelComposer::new(Vec::new(), Vec::new(), ComposerConfig::default(), 64).0;

    let internal_resolver = make_internal_resolver_with_tvar(
        vec![
--- a/nac3core/src/toplevel/type_annotation.rs
+++ b/nac3core/src/toplevel/type_annotation.rs
@ -1,9 +1,13 @@
-use super::*;
-use crate::symbol_resolver::SymbolValue;
-use crate::toplevel::helper::PrimDef;
-use crate::typecheck::typedef::VarMap;
+use strum::IntoEnumIterator;
+
 use nac3parser::ast::Constant;

+use super::{
+    helper::{PrimDef, PrimDefDetails},
+    *,
+};
+use crate::{symbol_resolver::SymbolValue, typecheck::typedef::VarMap};
+
 #[derive(Clone, Debug)]
 pub enum TypeAnnotation {
    Primitive(Type),
@ -357,6 +361,7 @@ pub fn parse_ast_to_type_annotation_kinds<T, S: std::hash::BuildHasher + Clone>(
 pub fn get_type_from_type_annotation_kinds(
    top_level_defs: &[Arc<RwLock<TopLevelDef>>],
    unifier: &mut Unifier,
+    primitives: &PrimitiveStore,
    ann: &TypeAnnotation,
    subst_list: &mut Option<Vec<Type>>,
 ) -> Result<Type, HashSet<String>> {
@ -379,10 +384,43 @@ pub fn get_type_from_type_annotation_kinds(
            let param_ty = params
                .iter()
                .map(|x| {
-                    get_type_from_type_annotation_kinds(top_level_defs, unifier, x, subst_list)
+                    get_type_from_type_annotation_kinds(
+                        top_level_defs,
+                        unifier,
+                        primitives,
+                        x,
+                        subst_list,
+                    )
                })
                .collect::<Result<Vec<_>, _>>()?;

+            let ty = if let Some(prim_def) = PrimDef::iter().find(|prim| prim.id() == *obj_id) {
+                // Primitive TopLevelDefs do not contain all fields that are present in their Type
+                // counterparts, so directly perform subst on the Type instead.
+
+                let PrimDefDetails::PrimClass { get_ty_fn, .. } = prim_def.details() else {
+                    unreachable!()
+                };
+
+                let base_ty = get_ty_fn(primitives);
+                let params =
+                    if let TypeEnum::TObj { params, .. } = &*unifier.get_ty_immutable(base_ty) {
+                        params.clone()
+                    } else {
+                        unreachable!()
+                    };
+
+                unifier
+                    .subst(
+                        get_ty_fn(primitives),
+                        &params
+                            .iter()
+                            .zip(param_ty)
+                            .map(|(obj_tv, param)| (*obj_tv.0, param))
+                            .collect(),
+                    )
+                    .unwrap_or(base_ty)
+            } else {
                let subst = {
                    // check for compatible range
                    // TODO: if allow type var to be applied(now this disallowed in the parse_to_type_annotation), need more check
@ -424,12 +462,15 @@ pub fn get_type_from_type_annotation_kinds(
                                }
                            }

-                        TypeEnum::TVar { id, range, name, loc, is_const_generic: true, .. } => {
+                            TypeEnum::TVar {
+                                id, range, name, loc, is_const_generic: true, ..
+                            } => {
                                let ty = range[0];
                                let ok: bool = {
                                    // create a temp type var and unify to check compatibility
                                    p == *tvar || {
-                                    let temp = unifier.get_fresh_const_generic_var(ty, *name, *loc);
+                                        let temp =
+                                            unifier.get_fresh_const_generic_var(ty, *name, *loc);
                                        unifier.unify(temp.ty, p).is_ok()
                                    }
                                };
@ -468,11 +509,16 @@ pub fn get_type_from_type_annotation_kinds(
                    fields: tobj_fields,
                    params: subst,
                });
+
                if need_subst {
                    if let Some(wl) = subst_list.as_mut() {
                        wl.push(ty);
                    }
                }
+
+                ty
+            };
+
            Ok(ty)
        }
        TypeAnnotation::Primitive(ty) | TypeAnnotation::TypeVar(ty) => Ok(*ty),
@ -490,6 +536,7 @@ pub fn get_type_from_type_annotation_kinds(
            let ty = get_type_from_type_annotation_kinds(
                top_level_defs,
                unifier,
+                primitives,
                ty.as_ref(),
                subst_list,
            )?;
@ -499,10 +546,16 @@ pub fn get_type_from_type_annotation_kinds(
            let tys = tys
                .iter()
                .map(|x| {
-                    get_type_from_type_annotation_kinds(top_level_defs, unifier, x, subst_list)
+                    get_type_from_type_annotation_kinds(
+                        top_level_defs,
+                        unifier,
+                        primitives,
+                        x,
+                        subst_list,
+                    )
                })
                .collect::<Result<Vec<_>, _>>()?;
-            Ok(unifier.add_ty(TypeEnum::TTuple { ty: tys }))
+            Ok(unifier.add_ty(TypeEnum::TTuple { ty: tys, is_vararg_ctx: false }))
        }
    }
 }
--- a/nac3core/src/typecheck/function_check.rs
+++ b/nac3core/src/typecheck/function_check.rs
@ -1,13 +1,19 @@
-use crate::toplevel::helper::PrimDef;
+use std::{
+    collections::{HashMap, HashSet},
+    iter::once,
+};

-use super::type_inferencer::Inferencer;
-use super::typedef::{Type, TypeEnum};
 use nac3parser::ast::{
    self, Constant, Expr, ExprKind,
    Operator::{LShift, RShift},
    Stmt, StmtKind, StrRef,
 };
-use std::{collections::HashSet, iter::once};
+
+use super::{
+    type_inferencer::{DeclarationSource, IdentifierInfo, Inferencer},
+    typedef::{Type, TypeEnum},
+};
+use crate::toplevel::helper::PrimDef;

 impl<'a> Inferencer<'a> {
    fn should_have_value(&mut self, expr: &Expr<Option<Type>>) -> Result<(), HashSet<String>> {
@ -21,26 +27,45 @@ impl<'a> Inferencer<'a> {
    fn check_pattern(
        &mut self,
        pattern: &Expr<Option<Type>>,
-        defined_identifiers: &mut HashSet<StrRef>,
+        defined_identifiers: &mut HashMap<StrRef, IdentifierInfo>,
    ) -> Result<(), HashSet<String>> {
        match &pattern.node {
            ExprKind::Name { id, .. } if id == &"none".into() => {
                Err(HashSet::from([format!("cannot assign to a `none` (at {})", pattern.location)]))
            }
            ExprKind::Name { id, .. } => {
-                if !defined_identifiers.contains(id) {
-                    defined_identifiers.insert(*id);
+                // If `id` refers to a declared symbol, reject this assignment if it is used in the
+                // context of an (implicit) global variable
+                if let Some(id_info) = defined_identifiers.get(id) {
+                    if matches!(
+                        id_info.source,
+                        DeclarationSource::Global { is_explicit: Some(false) }
+                    ) {
+                        return Err(HashSet::from([format!(
+                            "cannot access local variable '{id}' before it is declared (at {})",
+                            pattern.location
+                        )]));
+                    }
+                }
+
+                if !defined_identifiers.contains_key(id) {
+                    defined_identifiers.insert(*id, IdentifierInfo::default());
                }
                self.should_have_value(pattern)?;
                Ok(())
            }
-            ExprKind::Tuple { elts, .. } => {
+            ExprKind::List { elts, .. } | ExprKind::Tuple { elts, .. } => {
                for elt in elts {
                    self.check_pattern(elt, defined_identifiers)?;
                    self.should_have_value(elt)?;
                }
                Ok(())
            }
+            ExprKind::Starred { value, .. } => {
+                self.check_pattern(value, defined_identifiers)?;
+                self.should_have_value(value)?;
+                Ok(())
+            }
            ExprKind::Subscript { value, slice, .. } => {
                self.check_expr(value, defined_identifiers)?;
                self.should_have_value(value)?;
@ -64,7 +89,7 @@ impl<'a> Inferencer<'a> {
    fn check_expr(
        &mut self,
        expr: &Expr<Option<Type>>,
-        defined_identifiers: &mut HashSet<StrRef>,
+        defined_identifiers: &mut HashMap<StrRef, IdentifierInfo>,
    ) -> Result<(), HashSet<String>> {
        // there are some cases where the custom field is None
        if let Some(ty) = &expr.custom {
@ -85,7 +110,7 @@ impl<'a> Inferencer<'a> {
                    return Ok(());
                }
                self.should_have_value(expr)?;
-                if !defined_identifiers.contains(id) {
+                if !defined_identifiers.contains_key(id) {
                    match self.function_data.resolver.get_symbol_type(
                        self.unifier,
                        &self.top_level.definitions.read(),
@ -93,7 +118,22 @@ impl<'a> Inferencer<'a> {
                        *id,
                    ) {
                        Ok(_) => {
-                            self.defined_identifiers.insert(*id);
+                            let is_global = self.is_id_global(*id);
+
+                            defined_identifiers.insert(
+                                *id,
+                                IdentifierInfo {
+                                    source: match is_global {
+                                        Some(true) => {
+                                            DeclarationSource::Global { is_explicit: Some(false) }
+                                        }
+                                        Some(false) => {
+                                            DeclarationSource::Global { is_explicit: None }
+                                        }
+                                        None => DeclarationSource::Local,
+                                    },
+                                },
+                            );
                        }
                        Err(e) => {
                            return Err(HashSet::from([format!(
@ -166,9 +206,7 @@ impl<'a> Inferencer<'a> {
                let mut defined_identifiers = defined_identifiers.clone();
                for arg in &args.args {
                    // TODO: should we check the types here?
-                    if !defined_identifiers.contains(&arg.node.arg) {
-                        defined_identifiers.insert(arg.node.arg);
-                    }
+                    defined_identifiers.entry(arg.node.arg).or_default();
                }
                self.check_expr(body, &mut defined_identifiers)?;
            }
@ -207,6 +245,9 @@ impl<'a> Inferencer<'a> {
    /// This is a workaround preventing the caller from using a variable `alloca`-ed in the body, which
    /// is freed when the function returns.
    fn check_return_value_ty(&mut self, ret_ty: Type) -> bool {
+        if cfg!(feature = "no-escape-analysis") {
+            true
+        } else {
            match &*self.unifier.get_ty_immutable(ret_ty) {
                TypeEnum::TObj { .. } => [
                    self.primitives.int32,
@ -218,16 +259,17 @@ impl<'a> Inferencer<'a> {
                ]
                .iter()
                .any(|allowed_ty| self.unifier.unioned(ret_ty, *allowed_ty)),
-            TypeEnum::TTuple { ty } => ty.iter().all(|t| self.check_return_value_ty(*t)),
+                TypeEnum::TTuple { ty, .. } => ty.iter().all(|t| self.check_return_value_ty(*t)),
                _ => false,
            }
        }
+    }

    // check statements for proper identifier def-use and return on all paths
    fn check_stmt(
        &mut self,
        stmt: &Stmt<Option<Type>>,
-        defined_identifiers: &mut HashSet<StrRef>,
+        defined_identifiers: &mut HashMap<StrRef, IdentifierInfo>,
    ) -> Result<bool, HashSet<String>> {
        match &stmt.node {
            StmtKind::For { target, iter, body, orelse, .. } => {
@ -253,9 +295,11 @@ impl<'a> Inferencer<'a> {
                let body_returned = self.check_block(body, &mut body_identifiers)?;
                let orelse_returned = self.check_block(orelse, &mut orelse_identifiers)?;

-                for ident in &body_identifiers {
-                    if !defined_identifiers.contains(ident) && orelse_identifiers.contains(ident) {
-                        defined_identifiers.insert(*ident);
+                for ident in body_identifiers.keys() {
+                    if !defined_identifiers.contains_key(ident)
+                        && orelse_identifiers.contains_key(ident)
+                    {
+                        defined_identifiers.insert(*ident, IdentifierInfo::default());
                    }
                }
                Ok(body_returned && orelse_returned)
@ -286,7 +330,7 @@ impl<'a> Inferencer<'a> {
                    let mut defined_identifiers = defined_identifiers.clone();
                    let ast::ExcepthandlerKind::ExceptHandler { name, body, .. } = &handler.node;
                    if let Some(name) = name {
-                        defined_identifiers.insert(*name);
+                        defined_identifiers.insert(*name, IdentifierInfo::default());
                    }
                    self.check_block(body, &mut defined_identifiers)?;
                }
@ -350,6 +394,44 @@ impl<'a> Inferencer<'a> {
                }
                Ok(true)
            }
+            StmtKind::Global { names, .. } => {
+                for id in names {
+                    if let Some(id_info) = defined_identifiers.get(id) {
+                        if id_info.source == DeclarationSource::Local {
+                            return Err(HashSet::from([format!(
+                                "name '{id}' is referenced prior to global declaration at {}",
+                                stmt.location,
+                            )]));
+                        }
+
+                        continue;
+                    }
+
+                    match self.function_data.resolver.get_symbol_type(
+                        self.unifier,
+                        &self.top_level.definitions.read(),
+                        self.primitives,
+                        *id,
+                    ) {
+                        Ok(_) => {
+                            defined_identifiers.insert(
+                                *id,
+                                IdentifierInfo {
+                                    source: DeclarationSource::Global { is_explicit: Some(true) },
+                                },
+                            );
+                        }
+                        Err(e) => {
+                            return Err(HashSet::from([format!(
+                                "type error at identifier `{}` ({}) at {}",
+                                id, e, stmt.location
+                            )]))
+                        }
+                    }
+                }
+
+                Ok(false)
+            }
            // break, raise, etc.
            _ => Ok(false),
        }
@ -358,7 +440,7 @@ impl<'a> Inferencer<'a> {
    pub fn check_block(
        &mut self,
        block: &[Stmt<Option<Type>>],
-        defined_identifiers: &mut HashSet<StrRef>,
+        defined_identifiers: &mut HashMap<StrRef, IdentifierInfo>,
    ) -> Result<bool, HashSet<String>> {
        let mut ret = false;
        for stmt in block {
--- a/nac3core/src/typecheck/magic_methods.rs
+++ b/nac3core/src/typecheck/magic_methods.rs
@ -1,17 +1,21 @@
-use crate::symbol_resolver::SymbolValue;
-use crate::toplevel::helper::PrimDef;
-use crate::toplevel::numpy::{make_ndarray_ty, unpack_ndarray_var_tys};
-use crate::typecheck::{
+use std::{cmp::max, collections::HashMap, rc::Rc};
+
+use itertools::{iproduct, Itertools};
+use strum::IntoEnumIterator;
+
+use nac3parser::ast::{Cmpop, Operator, StrRef, Unaryop};
+
+use super::{
    type_inferencer::*,
    typedef::{FunSignature, FuncArg, Type, TypeEnum, Unifier, VarMap},
 };
-use itertools::{iproduct, Itertools};
-use nac3parser::ast::StrRef;
-use nac3parser::ast::{Cmpop, Operator, Unaryop};
-use std::cmp::max;
-use std::collections::HashMap;
-use std::rc::Rc;
-use strum::IntoEnumIterator;
+use crate::{
+    symbol_resolver::SymbolValue,
+    toplevel::{
+        helper::PrimDef,
+        numpy::{make_ndarray_ty, unpack_ndarray_var_tys},
+    },
+};

 /// The variant of a binary operator.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@ -197,6 +201,7 @@ pub fn impl_binop(
                            ty: other_ty,
                            default_value: None,
                            name: "other".into(),
+                            is_vararg: false,
                        }],
                    })),
                    false,
@ -261,6 +266,7 @@ pub fn impl_cmpop(
                            ty: other_ty,
                            default_value: None,
                            name: "other".into(),
+                            is_vararg: false,
                        }],
                    })),
                    false,
@ -518,6 +524,23 @@ pub fn typeof_binop(
        }

        Operator::MatMult => {
+            // NOTE: NumPy matmul's LHS and RHS must both be ndarrays. Scalars are not allowed.
+            match (&*unifier.get_ty(lhs), &*unifier.get_ty(rhs)) {
+                (
+                    TypeEnum::TObj { obj_id: lhs_obj_id, .. },
+                    TypeEnum::TObj { obj_id: rhs_obj_id, .. },
+                ) if *lhs_obj_id == primitives.ndarray.obj_id(unifier).unwrap()
+                    && *rhs_obj_id == primitives.ndarray.obj_id(unifier).unwrap() =>
+                {
+                    // LHS and RHS have valid types
+                }
+                _ => {
+                    let lhs_str = unifier.stringify(lhs);
+                    let rhs_str = unifier.stringify(rhs);
+                    return Err(format!("ndarray.__matmul__ only accepts ndarray operands, but left operand has type {lhs_str}, and right operand has type {rhs_str}"));
+                }
+            }
+
            let (_, lhs_ndims) = unpack_ndarray_var_tys(unifier, lhs);
            let lhs_ndims = match &*unifier.get_ty_immutable(lhs_ndims) {
                TypeEnum::TLiteral { values, .. } => {
@ -678,6 +701,7 @@ pub fn set_primitives_magic_methods(store: &PrimitiveStore, unifier: &mut Unifie
        bool: bool_t,
        uint32: uint32_t,
        uint64: uint64_t,
+        str: str_t,
        list: list_t,
        ndarray: ndarray_t,
        ..
@ -723,6 +747,9 @@ pub fn set_primitives_magic_methods(store: &PrimitiveStore, unifier: &mut Unifie
    impl_sign(unifier, store, bool_t, Some(int32_t));
    impl_eq(unifier, store, bool_t, &[bool_t, ndarray_bool_t], None);

+    /* str ========= */
+    impl_cmpop(unifier, store, str_t, &[str_t], &[Cmpop::Eq, Cmpop::NotEq], Some(bool_t));
+
    /* list ======== */
    impl_binop(unifier, store, list_t, &[list_t], Some(list_t), &[Operator::Add]);
    impl_binop(unifier, store, list_t, &[int32_t, int64_t], Some(list_t), &[Operator::Mult]);
--- a/nac3core/src/typecheck/type_error.rs
+++ b/nac3core/src/typecheck/type_error.rs
@ -1,14 +1,13 @@
-use std::collections::HashMap;
-use std::fmt::Display;
+use std::{collections::HashMap, fmt::Display};

-use crate::typecheck::{magic_methods::HasOpInfo, typedef::TypeEnum};
+use itertools::Itertools;
+
+use nac3parser::ast::{Cmpop, Location, StrRef};

 use super::{
-    magic_methods::Binop,
-    typedef::{RecordKey, Type, Unifier},
+    magic_methods::{Binop, HasOpInfo},
+    typedef::{RecordKey, Type, TypeEnum, Unifier},
 };
-use itertools::Itertools;
-use nac3parser::ast::{Cmpop, Location, StrRef};

 #[derive(Debug, Clone)]
 pub enum TypeErrorKind {
@ -183,9 +182,10 @@ impl<'a> Display for DisplayTypeError<'a> {
                        }
                        result
                    }
-                    (TypeEnum::TTuple { ty: ty1 }, TypeEnum::TTuple { ty: ty2 })
-                        if ty1.len() != ty2.len() =>
-                    {
+                    (
+                        TypeEnum::TTuple { ty: ty1, is_vararg_ctx: is_vararg1 },
+                        TypeEnum::TTuple { ty: ty2, is_vararg_ctx: is_vararg2 },
+                    ) if !is_vararg1 && !is_vararg2 && ty1.len() != ty2.len() => {
                        let t1 = self.unifier.stringify_with_notes(*t1, &mut notes);
                        let t2 = self.unifier.stringify_with_notes(*t2, &mut notes);
                        write!(f, "Tuple length mismatch: got {t1} and {t2}")
--- a/nac3core/src/typecheck/type_inferencer/mod.rs
+++ b/nac3core/src/typecheck/type_inferencer/mod.rs
--- a/nac3core/src/typecheck/type_inferencer/test.rs
+++ b/nac3core/src/typecheck/type_inferencer/test.rs
@ -1,18 +1,20 @@
-use super::super::{magic_methods::with_fields, typedef::*};
-use super::*;
-use crate::{
-    codegen::CodeGenContext,
-    symbol_resolver::ValueEnum,
-    toplevel::{helper::PrimDef, DefinitionId, TopLevelDef},
-};
+use std::iter::zip;
+
 use indexmap::IndexMap;
 use indoc::indoc;
-use nac3parser::ast::FileName;
-use nac3parser::parser::parse_program;
 use parking_lot::RwLock;
-use std::iter::zip;
 use test_case::test_case;

+use nac3parser::{ast::FileName, parser::parse_program};
+
+use super::*;
+use crate::{
+    codegen::{CodeGenContext, CodeGenerator},
+    symbol_resolver::ValueEnum,
+    toplevel::{helper::PrimDef, DefinitionId, TopLevelDef},
+    typecheck::{magic_methods::with_fields, typedef::*},
+};
+
 struct Resolver {
    id_to_type: HashMap<StrRef, Type>,
    id_to_def: HashMap<StrRef, DefinitionId>,
@ -41,6 +43,7 @@ impl SymbolResolver for Resolver {
        &self,
        _: StrRef,
        _: &mut CodeGenContext<'ctx, '_>,
+        _: &mut dyn CodeGenerator,
    ) -> Option<ValueEnum<'ctx>> {
        unimplemented!()
    }
@ -83,7 +86,12 @@ impl TestEnvironment {
        });
        with_fields(&mut unifier, int32, |unifier, fields| {
            let add_ty = unifier.add_ty(TypeEnum::TFunc(FunSignature {
-                args: vec![FuncArg { name: "other".into(), ty: int32, default_value: None }],
+                args: vec![FuncArg {
+                    name: "other".into(),
+                    ty: int32,
+                    default_value: None,
+                    is_vararg: false,
+                }],
                ret: int32,
                vars: VarMap::new(),
            }));
@ -224,7 +232,12 @@ impl TestEnvironment {
        });
        with_fields(&mut unifier, int32, |unifier, fields| {
            let add_ty = unifier.add_ty(TypeEnum::TFunc(FunSignature {
-                args: vec![FuncArg { name: "other".into(), ty: int32, default_value: None }],
+                args: vec![FuncArg {
+                    name: "other".into(),
+                    ty: int32,
+                    default_value: None,
+                    is_vararg: false,
+                }],
                ret: int32,
                vars: VarMap::new(),
            }));
@ -507,7 +520,7 @@ impl TestEnvironment {
            primitives: &mut self.primitives,
            virtual_checks: &mut self.virtual_checks,
            calls: &mut self.calls,
-            defined_identifiers: HashSet::default(),
+            defined_identifiers: HashMap::default(),
            in_handler: false,
        }
    }
@ -583,8 +596,9 @@ fn test_basic(source: &str, mapping: &HashMap<&str, &str>, virtuals: &[(&str, &s
    println!("source:\n{source}");
    let mut env = TestEnvironment::new();
    let id_to_name = std::mem::take(&mut env.id_to_name);
-    let mut defined_identifiers: HashSet<_> = env.identifier_mapping.keys().copied().collect();
-    defined_identifiers.insert("virtual".into());
+    let mut defined_identifiers: HashMap<_, _> =
+        env.identifier_mapping.keys().copied().map(|id| (id, IdentifierInfo::default())).collect();
+    defined_identifiers.insert("virtual".into(), IdentifierInfo::default());
    let mut inferencer = env.get_inferencer();
    inferencer.defined_identifiers.clone_from(&defined_identifiers);
    let statements = parse_program(source, FileName::default()).unwrap();
@ -729,8 +743,9 @@ fn test_primitive_magic_methods(source: &str, mapping: &HashMap<&str, &str>) {
    println!("source:\n{source}");
    let mut env = TestEnvironment::basic_test_env();
    let id_to_name = std::mem::take(&mut env.id_to_name);
-    let mut defined_identifiers: HashSet<_> = env.identifier_mapping.keys().copied().collect();
-    defined_identifiers.insert("virtual".into());
+    let mut defined_identifiers: HashMap<_, _> =
+        env.identifier_mapping.keys().copied().map(|id| (id, IdentifierInfo::default())).collect();
+    defined_identifiers.insert("virtual".into(), IdentifierInfo::default());
    let mut inferencer = env.get_inferencer();
    inferencer.defined_identifiers.clone_from(&defined_identifiers);
    let statements = parse_program(source, FileName::default()).unwrap();
--- a/nac3core/src/typecheck/typedef/mod.rs
+++ b/nac3core/src/typecheck/typedef/mod.rs
@ -1,23 +1,28 @@
+use std::{
+    borrow::Cow,
+    cell::RefCell,
+    collections::{HashMap, HashSet},
+    fmt::{self, Display},
+    iter::{repeat, zip},
+    rc::Rc,
+    sync::{Arc, Mutex},
+};
+
 use indexmap::IndexMap;
-use itertools::Itertools;
-use std::cell::RefCell;
-use std::collections::HashMap;
-use std::fmt::{self, Display};
-use std::iter::zip;
-use std::rc::Rc;
-use std::sync::{Arc, Mutex};
-use std::{borrow::Cow, collections::HashSet};
+use itertools::{repeat_n, Itertools};

 use nac3parser::ast::{Cmpop, Location, StrRef, Unaryop};

-use super::magic_methods::Binop;
-use super::type_error::{TypeError, TypeErrorKind};
-use super::unification_table::{UnificationKey, UnificationTable};
-use crate::symbol_resolver::SymbolValue;
-use crate::toplevel::helper::PrimDef;
-use crate::toplevel::{DefinitionId, TopLevelContext, TopLevelDef};
-use crate::typecheck::magic_methods::OpInfo;
-use crate::typecheck::type_inferencer::PrimitiveStore;
+use super::{
+    magic_methods::{Binop, HasOpInfo, OpInfo},
+    type_error::{TypeError, TypeErrorKind},
+    type_inferencer::PrimitiveStore,
+    unification_table::{UnificationKey, UnificationTable},
+};
+use crate::{
+    symbol_resolver::SymbolValue,
+    toplevel::{helper::PrimDef, DefinitionId, TopLevelContext, TopLevelDef},
+};

 #[cfg(test)]
 mod test;
@ -115,6 +120,7 @@ pub struct FuncArg {
    pub name: StrRef,
    pub ty: Type,
    pub default_value: Option<SymbolValue>,
+    pub is_vararg: bool,
 }

 impl FuncArg {
@ -233,6 +239,12 @@ pub enum TypeEnum {
    TTuple {
        /// The types of elements present in this tuple.
        ty: Vec<Type>,
+
+        /// Whether this tuple is used in a vararg context.
+        ///
+        /// If `true`, `ty` must only contain one type, and the tuple is assumed to contain any
+        /// number of `ty`-typed values.
+        is_vararg_ctx: bool,
    },

    /// An object type.
@ -527,7 +539,7 @@ impl Unifier {
            TypeEnum::TVirtual { ty } => self.get_instantiations(*ty).map(|ty| {
                ty.iter().map(|&ty| self.add_ty(TypeEnum::TVirtual { ty })).collect_vec()
            }),
-            TypeEnum::TTuple { ty } => {
+            TypeEnum::TTuple { ty, is_vararg_ctx } => {
                let tuples = ty
                    .iter()
                    .map(|ty| self.get_instantiations(*ty).unwrap_or_else(|| vec![*ty]))
@ -537,7 +549,12 @@ impl Unifier {
                    None
                } else {
                    Some(
-                        tuples.into_iter().map(|ty| self.add_ty(TypeEnum::TTuple { ty })).collect(),
+                        tuples
+                            .into_iter()
+                            .map(|ty| {
+                                self.add_ty(TypeEnum::TTuple { ty, is_vararg_ctx: *is_vararg_ctx })
+                            })
+                            .collect(),
                    )
                }
            }
@ -581,7 +598,7 @@ impl Unifier {
            TVar { .. } => allowed_typevars.iter().any(|b| self.unification_table.unioned(a, *b)),
            TCall { .. } => false,
            TVirtual { ty } => self.is_concrete(*ty, allowed_typevars),
-            TTuple { ty } => ty.iter().all(|ty| self.is_concrete(*ty, allowed_typevars)),
+            TTuple { ty, .. } => ty.iter().all(|ty| self.is_concrete(*ty, allowed_typevars)),
            TObj { params: vars, .. } => {
                vars.values().all(|ty| self.is_concrete(*ty, allowed_typevars))
            }
@ -649,6 +666,7 @@ impl Unifier {

        // Get details about the function signature/parameters.
        let num_params = signature.args.len();
+        let is_vararg = signature.args.iter().any(|arg| arg.is_vararg);

        // Force the type vars in `b` and `signature' to be up-to-date.
        let b = self.instantiate_fun(b, signature);
@ -659,8 +677,8 @@ impl Unifier {
        let num_args = posargs.len() + kwargs.len();

        // Now we check the arguments against the parameters,
-        // and depending on what `call_info` is, we might change how the behavior `unify_call()`
-        // in hopes to improve user error messages when type checking fails.
+        // and depending on what `call_info` is, we might change how `unify_call()` behaves
+        // to improve user error messages when type checking fails.
        match operator_info {
            Some(OperatorInfo::IsBinaryOp { self_type, operator }) => {
                // The call is written in the form of (say) `a + b`.
@ -737,7 +755,7 @@ impl Unifier {
                };

                // Check for "too many arguments"
-                if num_params < posargs.len() {
+                if !is_vararg && num_params < posargs.len() {
                    let expected_min_count =
                        signature.args.iter().filter(|param| param.is_required()).count();
                    let expected_max_count = num_params;
@ -770,6 +788,19 @@ impl Unifier {
                    type_check_arg(param.name, param.ty, arg_ty)?;
                }

+                if is_vararg {
+                    debug_assert!(!signature.args.is_empty());
+
+                    let vararg_args = posargs.iter().skip(signature.args.len());
+                    let vararg_param = signature.args.last().unwrap();
+
+                    for (&arg_ty, param) in zip(vararg_args, repeat(vararg_param)) {
+                        // `param_info` for this argument would've already been marked as supplied
+                        // during non-vararg posarg typecheck
+                        type_check_arg(param.name, param.ty, arg_ty)?;
+                    }
+                }
+
                // Now consume all keyword arguments and typecheck them.
                for (&param_name, &arg_ty) in kwargs {
                    // We will also use this opportunity to check if this keyword argument is "legal".
@ -959,7 +990,10 @@ impl Unifier {
                self.unify_impl(x, b, false)?;
                self.set_a_to_b(a, x);
            }
-            (TVar { fields: Some(fields), range, is_const_generic: false, .. }, TTuple { ty }) => {
+            (
+                TVar { fields: Some(fields), range, is_const_generic: false, .. },
+                TTuple { ty, .. },
+            ) => {
                let len = i32::try_from(ty.len()).unwrap();
                for (k, v) in fields {
                    match *k {
@ -980,8 +1014,18 @@ impl Unifier {
                            self.unify_impl(v.ty, ty[ind as usize], false)
                                .map_err(|e| e.at(v.loc))?;
                        }
-                        RecordKey::Str(_) => {
-                            return Err(TypeError::new(TypeErrorKind::NoSuchField(*k, b), v.loc))
+                        RecordKey::Str(s) => {
+                            let tuple_fns = [
+                                Cmpop::Eq.op_info().method_name,
+                                Cmpop::NotEq.op_info().method_name,
+                            ];
+
+                            if !tuple_fns.into_iter().any(|op| s.to_string() == op) {
+                                return Err(TypeError::new(
+                                    TypeErrorKind::NoSuchField(*k, b),
+                                    v.loc,
+                                ));
+                            }
                        }
                    }
                }
@ -1056,15 +1100,47 @@ impl Unifier {
                self.set_a_to_b(a, b);
            }

-            (TTuple { ty: ty1 }, TTuple { ty: ty2 }) => {
-                if ty1.len() != ty2.len() {
-                    return Err(TypeError::new(TypeErrorKind::IncompatibleTypes(a, b), None));
+            (
+                TTuple { ty: ty1, is_vararg_ctx: is_vararg1 },
+                TTuple { ty: ty2, is_vararg_ctx: is_vararg2 },
+            ) => {
+                // Rules for Tuples:
+                // - ty1: is_vararg && ty2: is_vararg -> ty1[0] == ty2[0]
+                // - ty1: is_vararg && ty2: !is_vararg -> type error (not enough info to infer the correct number of arguments)
+                // - ty1: !is_vararg && ty2: is_vararg -> ty1[..] == ty2[0]
+                // - ty1: !is_vararg && ty2: !is_vararg -> ty1.len() == ty2.len() && ty1[i] == ty2[i]
+
+                debug_assert!(!is_vararg1 || ty1.len() == 1);
+                debug_assert!(!is_vararg2 || ty2.len() == 1);
+
+                match (*is_vararg1, *is_vararg2) {
+                    (true, true) => {
+                        if self.unify_impl(ty1[0], ty2[0], false).is_err() {
+                            return Self::incompatible_types(a, b);
                        }
+                    }
+                    (true, false) => return Self::incompatible_types(a, b),
+
+                    (false, true) => {
+                        for y in ty2 {
+                            if self.unify_impl(ty1[0], *y, false).is_err() {
+                                return Self::incompatible_types(a, b);
+                            }
+                        }
+                    }
+                    (false, false) => {
+                        if ty1.len() != ty2.len() {
+                            return Self::incompatible_types(a, b);
+                        }
+
                        for (x, y) in ty1.iter().zip(ty2.iter()) {
                            if self.unify_impl(*x, *y, false).is_err() {
-                        return Err(TypeError::new(TypeErrorKind::IncompatibleTypes(a, b), None));
+                                return Self::incompatible_types(a, b);
                            }
                        }
+                    }
+                }
+
                self.set_a_to_b(a, b);
            }
            (TVar { fields: Some(map), range, .. }, TObj { obj_id, fields, params }) => {
@ -1307,11 +1383,23 @@ impl Unifier {
            TypeEnum::TLiteral { values, .. } => {
                format!("const({})", values.iter().map(|v| format!("{v:?}")).join(", "))
            }
-            TypeEnum::TTuple { ty } => {
-                let mut fields =
-                    ty.iter().map(|v| self.internal_stringify(*v, obj_to_name, var_to_name, notes));
+            TypeEnum::TTuple { ty, is_vararg_ctx } => {
+                if *is_vararg_ctx {
+                    debug_assert_eq!(ty.len(), 1);
+                    let field = self.internal_stringify(
+                        *ty.iter().next().unwrap(),
+                        obj_to_name,
+                        var_to_name,
+                        notes,
+                    );
+                    format!("tuple[*{field}]")
+                } else {
+                    let mut fields = ty
+                        .iter()
+                        .map(|v| self.internal_stringify(*v, obj_to_name, var_to_name, notes));
                    format!("tuple[{}]", fields.join(", "))
                }
+            }
            TypeEnum::TVirtual { ty } => {
                format!(
                    "virtual[{}]",
@ -1335,17 +1423,21 @@ impl Unifier {
                    .args
                    .iter()
                    .map(|arg| {
+                        let vararg_prefix = if arg.is_vararg { "*" } else { "" };
+
                        if let Some(dv) = &arg.default_value {
                            format!(
-                                "{}:{}={}",
+                                "{}:{}{}={}",
                                arg.name,
+                                vararg_prefix,
                                self.internal_stringify(arg.ty, obj_to_name, var_to_name, notes),
                                dv
                            )
                        } else {
                            format!(
-                                "{}:{}",
+                                "{}:{}{}",
                                arg.name,
+                                vararg_prefix,
                                self.internal_stringify(arg.ty, obj_to_name, var_to_name, notes)
                            )
                        }
@ -1431,7 +1523,7 @@ impl Unifier {
        match &*ty {
            TypeEnum::TRigidVar { .. } | TypeEnum::TLiteral { .. } => None,
            TypeEnum::TVar { id, .. } => mapping.get(id).copied(),
-            TypeEnum::TTuple { ty } => {
+            TypeEnum::TTuple { ty, is_vararg_ctx } => {
                let mut new_ty = Cow::from(ty);
                for (i, t) in ty.iter().enumerate() {
                    if let Some(t1) = self.subst_impl(*t, mapping, cache) {
@ -1439,7 +1531,10 @@ impl Unifier {
                    }
                }
                if matches!(new_ty, Cow::Owned(_)) {
-                    Some(self.add_ty(TypeEnum::TTuple { ty: new_ty.into_owned() }))
+                    Some(self.add_ty(TypeEnum::TTuple {
+                        ty: new_ty.into_owned(),
+                        is_vararg_ctx: *is_vararg_ctx,
+                    }))
                } else {
                    None
                }
@ -1599,16 +1694,37 @@ impl Unifier {
                }
            }
            (TVar { range, .. }, _) => self.check_var_compatibility(b, range).or(Err(())),
-            (TTuple { ty: ty1 }, TTuple { ty: ty2 }) if ty1.len() == ty2.len() => {
-                let ty: Vec<_> = zip(ty1.iter(), ty2.iter())
-                    .map(|(a, b)| self.get_intersection(*a, *b))
-                    .try_collect()?;
-                if ty.iter().any(Option::is_some) {
-                    Ok(Some(self.add_ty(TTuple {
-                        ty: zip(ty, ty1.iter()).map(|(a, b)| a.unwrap_or(*b)).collect(),
-                    })))
+            (
+                TTuple { ty: ty1, is_vararg_ctx: is_vararg1 },
+                TTuple { ty: ty2, is_vararg_ctx: is_vararg2 },
+            ) => {
+                if *is_vararg1 && *is_vararg2 {
+                    let isect_ty = self.get_intersection(ty1[0], ty2[0])?;
+                    Ok(isect_ty.map(|ty| self.add_ty(TTuple { ty: vec![ty], is_vararg_ctx: true })))
                } else {
-                    Ok(None)
+                    let zip_iter: Box<dyn Iterator<Item = (&Type, &Type)>> =
+                        match (*is_vararg1, *is_vararg2) {
+                            (true, _) => Box::new(repeat_n(&ty1[0], ty2.len()).zip(ty2.iter())),
+                            (_, false) => Box::new(ty1.iter().zip(repeat_n(&ty2[0], ty1.len()))),
+                            _ => {
+                                if ty1.len() != ty2.len() {
+                                    return Err(());
+                                }
+
+                                Box::new(ty1.iter().zip(ty2.iter()))
+                            }
+                        };
+
+                    let ty: Vec<_> =
+                        zip_iter.map(|(a, b)| self.get_intersection(*a, *b)).try_collect()?;
+                    Ok(if ty.iter().any(Option::is_some) {
+                        Some(self.add_ty(TTuple {
+                            ty: zip(ty, ty1.iter()).map(|(a, b)| a.unwrap_or(*b)).collect(),
+                            is_vararg_ctx: false,
+                        }))
+                    } else {
+                        None
+                    })
                }
            }
            // TODO(Derppening): #444
--- a/nac3core/src/typecheck/typedef/test.rs
+++ b/nac3core/src/typecheck/typedef/test.rs
@ -1,10 +1,12 @@
-use super::super::magic_methods::with_fields;
-use super::*;
+use std::collections::HashMap;
+
 use indoc::indoc;
 use itertools::Itertools;
-use std::collections::HashMap;
 use test_case::test_case;

+use super::*;
+use crate::typecheck::magic_methods::with_fields;
+
 impl Unifier {
    /// Check whether two types are equal.
    fn eq(&mut self, a: Type, b: Type) -> bool {
@ -28,7 +30,10 @@ impl Unifier {
                TypeEnum::TVar { fields: Some(map1), .. },
                TypeEnum::TVar { fields: Some(map2), .. },
            ) => self.map_eq2(map1, map2),
-            (TypeEnum::TTuple { ty: ty1 }, TypeEnum::TTuple { ty: ty2 }) => {
+            (
+                TypeEnum::TTuple { ty: ty1, is_vararg_ctx: false },
+                TypeEnum::TTuple { ty: ty2, is_vararg_ctx: false },
+            ) => {
                ty1.len() == ty2.len()
                    && ty1.iter().zip(ty2.iter()).all(|(t1, t2)| self.eq(*t1, *t2))
            }
@ -178,7 +183,7 @@ impl TestEnvironment {
                    ty.push(result.0);
                    s = result.1;
                }
-                (self.unifier.add_ty(TypeEnum::TTuple { ty }), &s[1..])
+                (self.unifier.add_ty(TypeEnum::TTuple { ty, is_vararg_ctx: false }), &s[1..])
            }
            "Record" => {
                let mut s = &typ[end..];
@ -608,7 +613,7 @@ fn test_instantiation() {
    let v1 = env.unifier.get_fresh_var_with_range(&[list_v, int], None, None).ty;
    let v2 = env.unifier.get_fresh_var_with_range(&[list_int, float], None, None).ty;
    let t = env.unifier.get_dummy_var().ty;
-    let tuple = env.unifier.add_ty(TypeEnum::TTuple { ty: vec![v, v1, v2] });
+    let tuple = env.unifier.add_ty(TypeEnum::TTuple { ty: vec![v, v1, v2], is_vararg_ctx: false });
    let v3 = env.unifier.get_fresh_var_with_range(&[tuple, t], None, None).ty;
    // t = TypeVar('t')
    // v = TypeVar('v', int, bool)
--- a/nac3ld/src/dwarf.rs
+++ b/nac3ld/src/dwarf.rs
@ -238,7 +238,7 @@ impl<'a> EH_Frame<'a> {
 /// From the [specification](https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html):
 ///
 /// > Each CFI record contains a Common Information Entry (CIE) record followed by 1 or more Frame
-/// Description Entry (FDE) records.
+/// > Description Entry (FDE) records.
 pub struct CFI_Record<'a> {
    // It refers to the augmentation data that corresponds to 'R' in the augmentation string
    fde_pointer_encoding: u8,
--- a/nac3ld/src/lib.rs
+++ b/nac3ld/src/lib.rs
@ -21,13 +21,12 @@
    clippy::wildcard_imports
 )]

+use std::{collections::HashMap, mem, ptr, slice, str};
+
+use byteorder::{ByteOrder, LittleEndian};
+
 use dwarf::*;
 use elf::*;
-use std::collections::HashMap;
-use std::{mem, ptr, slice, str};
-
-extern crate byteorder;
-use byteorder::{ByteOrder, LittleEndian};

 mod dwarf;
 mod elf;
--- a/nac3parser/Cargo.toml
+++ b/nac3parser/Cargo.toml
@ -8,15 +8,15 @@ license = "MIT"
 edition = "2021"

 [build-dependencies]
-lalrpop = "0.20"
+lalrpop = "0.22"

 [dependencies]
 nac3ast = { path = "../nac3ast" }
-lalrpop-util = "0.20"
+lalrpop-util = "0.22"
 log = "0.4"
 unic-emoji-char = "0.9"
 unic-ucd-ident  = "0.9"
-unicode_names2 = "1.2"
+unicode_names2 = "1.3"
 phf = { version = "0.11", features = ["macros"] }
 ahash = "0.8"

--- a/nac3parser/src/config_comment_helper.rs
+++ b/nac3parser/src/config_comment_helper.rs
@ -1,8 +1,10 @@
-use crate::ast::Ident;
-use crate::ast::Location;
-use crate::error::*;
-use crate::token::Tok;
+use crate::{
+    ast::{Ident, Location},
+    error::*,
+    token::Tok,
+};
 use lalrpop_util::ParseError;
+
 use nac3ast::*;

 pub fn make_config_comment(
--- a/nac3parser/src/error.rs
+++ b/nac3parser/src/error.rs
@ -1,13 +1,12 @@
 //! Define internal parse error types
 //! The goal is to provide a matching and a safe error API, maksing errors from LALR
-use lalrpop_util::ParseError as LalrpopError;
-
-use crate::ast::Location;
-use crate::token::Tok;
-
 use std::error::Error;
 use std::fmt;

+use lalrpop_util::ParseError as LalrpopError;
+
+use crate::{ast::Location, token::Tok};
+
 /// Represents an error during lexical scanning.
 #[derive(Debug, PartialEq)]
 pub struct LexicalError {
--- a/nac3parser/src/fstring.rs
+++ b/nac3parser/src/fstring.rs
@ -1,12 +1,11 @@
-use std::iter;
-use std::mem;
-use std::str;
-
-use crate::ast::{Constant, ConversionFlag, Expr, ExprKind, Location};
-use crate::error::{FStringError, FStringErrorType, ParseError};
-use crate::parser::parse_expression;
+use std::{iter, mem, str};

 use self::FStringErrorType::*;
+use crate::{
+    ast::{Constant, ConversionFlag, Expr, ExprKind, Location},
+    error::{FStringError, FStringErrorType, ParseError},
+    parser::parse_expression,
+};

 struct FStringParser<'a> {
    chars: iter::Peekable<str::Chars<'a>>,
--- a/nac3parser/src/function.rs
+++ b/nac3parser/src/function.rs
@ -1,8 +1,11 @@
-use ahash::RandomState;
 use std::collections::HashSet;

-use crate::ast;
-use crate::error::{LexicalError, LexicalErrorType};
+use ahash::RandomState;
+
+use crate::{
+    ast,
+    error::{LexicalError, LexicalErrorType},
+};

 pub struct ArgumentList {
    pub args: Vec<ast::Expr>,
--- a/nac3parser/src/lexer.rs
+++ b/nac3parser/src/lexer.rs
@ -1,17 +1,17 @@
 //! This module takes care of lexing python source text.
 //!
 //! This means source code is translated into separate tokens.
+use std::{char, cmp::Ordering, num::IntErrorKind, str::FromStr};

-pub use super::token::Tok;
-use crate::ast::{FileName, Location};
-use crate::error::{LexicalError, LexicalErrorType};
-use std::char;
-use std::cmp::Ordering;
-use std::num::IntErrorKind;
-use std::str::FromStr;
 use unic_emoji_char::is_emoji_presentation;
 use unic_ucd_ident::{is_xid_continue, is_xid_start};

+pub use super::token::Tok;
+use crate::{
+    ast::{FileName, Location},
+    error::{LexicalError, LexicalErrorType},
+};
+
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 struct IndentationLevel {
    tabs: usize,
--- a/nac3parser/src/parser.rs
+++ b/nac3parser/src/parser.rs
@ -5,14 +5,16 @@
 //! parse a whole program, a single statement, or a single
 //! expression.

-use nac3ast::Location;
 use std::iter;

-use crate::ast::{self, FileName};
-use crate::error::ParseError;
-use crate::lexer;
+use nac3ast::Location;
+
 pub use crate::mode::Mode;
-use crate::python;
+use crate::{
+    ast::{self, FileName},
+    error::ParseError,
+    lexer, python,
+};

 /*
 * Parse python code.
--- a/nac3parser/src/token.rs
+++ b/nac3parser/src/token.rs
@ -1,8 +1,9 @@
 //! Different token definitions.
 //! Loosely based on token.h from CPython source:
-use crate::ast;
 use std::fmt::{self, Write};

+use crate::ast;
+
 /// Python source code can be tokenized in a sequence of these tokens.
 #[derive(Clone, Debug, PartialEq)]
 pub enum Tok {
--- a/nac3standalone/Cargo.toml
+++ b/nac3standalone/Cargo.toml
@ -4,16 +4,13 @@ version = "0.1.0"
 authors = ["M-Labs"]
 edition = "2021"

+[features]
+no-escape-analysis = ["nac3core/no-escape-analysis"]
+
 [dependencies]
 parking_lot = "0.12"
-nac3parser = { path = "../nac3parser" }
 nac3core = { path = "../nac3core" }

 [dependencies.clap]
 version = "4.5"
 features = ["derive"]
-
-[dependencies.inkwell]
-version = "0.4"
-default-features = false
-features = ["llvm14-0", "target-x86", "target-arm", "target-riscv", "no-libffi-linking"]
--- a/nac3standalone/demo/check_demo.sh
+++ b/nac3standalone/demo/check_demo.sh
@ -3,23 +3,66 @@
 set -e

 if [ -z "$1" ]; then
-  echo "Requires at least one argument"
+    echo "No argument supplied"
    exit 1
 fi

 declare -a nac3args
+while [ $# -gt 1 ]; do
+  case "$1" in
+    --help)
+      echo "Usage: check_demo.sh [--debug] [-i686] -- [NAC3ARGS...] demo"
+      exit
+      ;;
+    --debug)
+      debug=1
+      ;;
+    -i686)
+      i686=1
+      ;;
+    --)
+      shift
+      break
+      ;;
+    *)
+      echo "Unrecognized argument \"$1\""
+      exit 1
+      ;;
+  esac
+  shift
+done
+
 while [ $# -gt 1 ]; do
  nac3args+=("$1")
  shift
 done
 demo="$1"

-echo -n "Checking $demo... "
-./interpret_demo.py "$demo" > interpreted.log
-./run_demo.sh --out run.log "${nac3args[@]}" "$demo"
-./run_demo.sh --lli --out run_lli.log "${nac3args[@]}" "$demo"
-diff -Nau interpreted.log run.log
-diff -Nau interpreted.log run_lli.log
-echo "ok"

-rm -f interpreted.log run.log run_lli.log
+echo "### Checking $demo..."
+
+echo ">>>>>> Running $demo with the Python interpreter"
+./interpret_demo.py "$demo" > interpreted.log
+
+if [ -n "$i686" ]; then
+  echo "...... Trying NAC3's 32-bit code generator output"
+  if [ -n "$debug" ]; then
+    ./run_demo.sh --debug -i686 --out run_32.log -- "${nac3args[@]}" "$demo"
+  else
+    ./run_demo.sh -i686 --out run_32.log -- "${nac3args[@]}" "$demo"
+  fi
+  diff -Nau interpreted.log run_32.log
+fi
+
+echo "...... Trying NAC3's 64-bit code generator output"
+if [ -n "$debug" ]; then
+  ./run_demo.sh --debug --out run_64.log -- "${nac3args[@]}" "$demo"
+else
+  ./run_demo.sh --out run_64.log -- "${nac3args[@]}" "$demo"
+fi
+diff -Nau interpreted.log run_64.log
+
+echo "...... OK"
+
+rm -f interpreted.log \
+  run_32.log run_64.log
--- a/nac3standalone/demo/check_demos.sh
+++ b/nac3standalone/demo/check_demos.sh
@ -2,6 +2,11 @@

 set -e

+if [ "$1" == "--help" ]; then
+    echo "Usage: check_demos.sh [CHECKARGS...] [--] [NAC3ARGS...]"
+    exit
+fi
+
 count=0
 for demo in src/*.py; do
  ./check_demo.sh "$@" "$demo"
--- a/nac3standalone/demo/demo.c
+++ b/nac3standalone/demo/demo.c
@ -6,8 +6,6 @@
 #include <stdlib.h>
 #include <string.h>

-#define usize size_t
-
 double dbl_nan(void) {
    return NAN;
 }
@ -64,14 +62,14 @@ void output_asciiart(int32_t x) {

 struct cslice {
    void* data;
-    usize len;
+    size_t len;
 };

 void output_int32_list(struct cslice* slice) {
    const int32_t* data = (int32_t*)slice->data;

    putchar('[');
-    for (usize i = 0; i < slice->len; ++i) {
+    for (size_t i = 0; i < slice->len; ++i) {
        if (i == slice->len - 1) {
            printf("%d", data[i]);
        } else {
@ -85,7 +83,7 @@ void output_int32_list(struct cslice *slice) {
 void output_str(struct cslice* slice) {
    const char* data = (const char*)slice->data;

-    for (usize i = 0; i < slice->len; ++i) {
+    for (size_t i = 0; i < slice->len; ++i) {
        putchar(data[i]);
    }
 }
@ -107,8 +105,26 @@ uint32_t __nac3_personality(uint32_t state, uint32_t exception_object, uint32_t
    __builtin_unreachable();
 }

-uint32_t __nac3_raise(uint32_t state, uint32_t exception_object, uint32_t context) {
-    printf("__nac3_raise(state: %u, exception_object: %u, context: %u)\n", state, exception_object, context);
+// See `struct Exception<'a>` in
+// https://github.com/m-labs/artiq/blob/master/artiq/firmware/libeh/eh_artiq.rs
+struct Exception {
+    uint32_t id;
+    struct cslice file;
+    uint32_t line;
+    uint32_t column;
+    struct cslice function;
+    struct cslice message;
+    int64_t param[3];
+};
+
+uint32_t __nac3_raise(struct Exception* e) {
+    printf("__nac3_raise called. Exception details:\n");
+    printf("          ID: %" PRIu32 "\n", e->id);
+    printf("    Location: %*s:%" PRIu32 ":%" PRIu32 "\n", (int)e->file.len, (const char*)e->file.data, e->line,
+           e->column);
+    printf("    Function: %*s\n", (int)e->function.len, (const char*)e->function.data);
+    printf("     Message: \"%*s\"\n", (int)e->message.len, (const char*)e->message.data);
+    printf("      Params: {0}=%" PRId64 ", {1}=%" PRId64 ", {2}=%" PRId64 "\n", e->param[0], e->param[1], e->param[2]);
    exit(101);
    __builtin_unreachable();
 }
--- a/nac3standalone/demo/interpret_demo.py
+++ b/nac3standalone/demo/interpret_demo.py
@ -6,6 +6,7 @@ import importlib.machinery
 import math
 import numpy as np
 import numpy.typing as npt
+import scipy as sp
 import pathlib

 from numpy import int32, int64, uint32, uint64
@ -167,7 +168,7 @@ def patch(module):
    module.ceil64 = _ceil
    module.np_ceil = np.ceil

-    # NumPy ndarray functions
+    # NumPy NDArray factory functions
    module.ndarray = NDArray
    module.np_ndarray = np.ndarray
    module.np_empty = np.empty
@ -183,8 +184,10 @@ def patch(module):
    module.np_isinf = np.isinf
    module.np_min = np.min
    module.np_minimum = np.minimum
+    module.np_argmin = np.argmin
    module.np_max = np.max
    module.np_maximum = np.maximum
+    module.np_argmax = np.argmax
    module.np_sin = np.sin
    module.np_cos = np.cos
    module.np_exp = np.exp
@ -215,8 +218,10 @@ def patch(module):
    module.np_ldexp = np.ldexp
    module.np_hypot = np.hypot
    module.np_nextafter = np.nextafter
+    module.np_transpose = np.transpose
+    module.np_reshape = np.reshape

-    # SciPy Math Functions
+    # SciPy Math functions
    module.sp_spec_erf = special.erf
    module.sp_spec_erfc = special.erfc
    module.sp_spec_gamma = special.gamma
@ -224,14 +229,19 @@ def patch(module):
    module.sp_spec_j0 = special.j0
    module.sp_spec_j1 = special.j1

-    # NumPy NDArray Functions
-    module.np_ndarray = np.ndarray
-    module.np_empty = np.empty
-    module.np_zeros = np.zeros
-    module.np_ones = np.ones
-    module.np_full = np.full
-    module.np_eye = np.eye
-    module.np_identity = np.identity
+    # Linalg functions
+    module.np_dot = np.dot
+    module.np_linalg_cholesky = np.linalg.cholesky
+    module.np_linalg_qr = np.linalg.qr
+    module.np_linalg_svd = np.linalg.svd
+    module.np_linalg_inv = np.linalg.inv
+    module.np_linalg_pinv = np.linalg.pinv
+    module.np_linalg_matrix_power = np.linalg.matrix_power
+    module.np_linalg_det = np.linalg.det
+    
+    module.sp_linalg_lu = lambda x: sp.linalg.lu(x, True)
+    module.sp_linalg_schur = sp.linalg.schur
+    module.sp_linalg_hessenberg = lambda x: sp.linalg.hessenberg(x, True)

 def file_import(filename, prefix="file_import_"):
    filename = pathlib.Path(filename)
--- a/nac3standalone/demo/linalg/Cargo.lock
+++ b/nac3standalone/demo/linalg/Cargo.lock
@ -0,0 +1,114 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "approx"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
+
+[[package]]
+name = "cslice"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f8cb7306107e4b10e64994de6d3274bd08996a7c1322a27b86482392f96be0a"
+
+[[package]]
+name = "libm"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
+
+[[package]]
+name = "linalg"
+version = "0.1.0"
+dependencies = [
+ "cslice",
+ "nalgebra",
+]
+
+[[package]]
+name = "nalgebra"
+version = "0.32.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b5c17de023a86f59ed79891b2e5d5a94c705dbe904a5b5c9c952ea6221b03e4"
+dependencies = [
+ "approx",
+ "num-complex",
+ "num-rational",
+ "num-traits",
+ "simba",
+ "typenum",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+ "libm",
+]
+
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
+[[package]]
+name = "simba"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "061507c94fc6ab4ba1c9a0305018408e312e17c041eb63bef8aa726fa33aceae"
+dependencies = [
+ "approx",
+ "num-complex",
+ "num-traits",
+ "paste",
+]
+
+[[package]]
+name = "typenum"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
--- a/nac3standalone/demo/linalg/Cargo.toml
+++ b/nac3standalone/demo/linalg/Cargo.toml
@ -0,0 +1,13 @@
+[package]
+name = "linalg"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["staticlib"]
+
+[dependencies]
+nalgebra = {version = "0.32.6", default-features = false, features = ["libm", "alloc"]}
+cslice = "0.3.0"
+
+[workspace]
--- a/nac3standalone/demo/linalg/src/lib.rs
+++ b/nac3standalone/demo/linalg/src/lib.rs
@ -0,0 +1,406 @@
+// Uses `nalgebra` crate to invoke `np_linalg` and `sp_linalg` functions
+// When converting between `nalgebra::Matrix` and `NDArray` following considerations are necessary
+//
+// * Both `nalgebra::Matrix` and `NDArray` require their content to be stored in row-major order
+// * `NDArray` data pointer can be directly read and converted to `nalgebra::Matrix` (row and column number must be known)
+// * `nalgebra::Matrix::as_slice` returns the content of matrix in column-major order and initial data needs to be transposed before storing it in `NDArray` data pointer
+
+use core::slice;
+use nalgebra::DMatrix;
+
+fn report_error(
+    error_name: &str,
+    fn_name: &str,
+    file_name: &str,
+    line_num: u32,
+    col_num: u32,
+    err_msg: &str,
+) -> ! {
+    panic!(
+        "Exception {} from {} in {}:{}:{}, message: {}",
+        error_name, fn_name, file_name, line_num, col_num, err_msg
+    );
+}
+
+pub struct InputMatrix {
+    pub ndims: usize,
+    pub dims: *const usize,
+    pub data: *mut f64,
+}
+impl InputMatrix {
+    fn get_dims(&mut self) -> Vec<usize> {
+        let dims = unsafe { slice::from_raw_parts(self.dims, self.ndims) };
+        dims.to_vec()
+    }
+}
+
+/// # Safety
+///
+/// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
+#[no_mangle]
+pub unsafe extern "C" fn np_linalg_cholesky(mat1: *mut InputMatrix, out: *mut InputMatrix) {
+    let mat1 = mat1.as_mut().unwrap();
+    let out = out.as_mut().unwrap();
+
+    if mat1.ndims != 2 {
+        let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
+        report_error("ValueError", "np_linalg_cholesky", file!(), line!(), column!(), &err_msg);
+    }
+
+    let dim1 = (*mat1).get_dims();
+    if dim1[0] != dim1[1] {
+        let err_msg =
+            format!("last 2 dimensions of the array must be square: {0} != {1}", dim1[0], dim1[1]);
+        report_error("LinAlgError", "np_linalg_cholesky", file!(), line!(), column!(), &err_msg);
+    }
+
+    let outdim = out.get_dims();
+    let out_slice = unsafe { slice::from_raw_parts_mut(out.data, outdim[0] * outdim[1]) };
+    let data_slice1 = unsafe { slice::from_raw_parts_mut(mat1.data, dim1[0] * dim1[1]) };
+
+    let matrix1 = DMatrix::from_row_slice(dim1[0], dim1[1], data_slice1);
+    let result = matrix1.cholesky();
+    match result {
+        Some(res) => {
+            out_slice.copy_from_slice(res.unpack().transpose().as_slice());
+        }
+        None => {
+            report_error(
+                "LinAlgError",
+                "np_linalg_cholesky",
+                file!(),
+                line!(),
+                column!(),
+                "Matrix is not positive definite",
+            );
+        }
+    };
+}
+
+/// # Safety
+///
+/// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
+#[no_mangle]
+pub unsafe extern "C" fn np_linalg_qr(
+    mat1: *mut InputMatrix,
+    out_q: *mut InputMatrix,
+    out_r: *mut InputMatrix,
+) {
+    let mat1 = mat1.as_mut().unwrap();
+    let out_q = out_q.as_mut().unwrap();
+    let out_r = out_r.as_mut().unwrap();
+
+    if mat1.ndims != 2 {
+        let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
+        report_error("ValueError", "np_linalg_cholesky", file!(), line!(), column!(), &err_msg);
+    }
+
+    let dim1 = (*mat1).get_dims();
+    let outq_dim = (*out_q).get_dims();
+    let outr_dim = (*out_r).get_dims();
+
+    let data_slice1 = unsafe { slice::from_raw_parts_mut(mat1.data, dim1[0] * dim1[1]) };
+    let out_q_slice = unsafe { slice::from_raw_parts_mut(out_q.data, outq_dim[0] * outq_dim[1]) };
+    let out_r_slice = unsafe { slice::from_raw_parts_mut(out_r.data, outr_dim[0] * outr_dim[1]) };
+
+    // Refer to https://github.com/dimforge/nalgebra/issues/735
+    let matrix1 = DMatrix::from_row_slice(dim1[0], dim1[1], data_slice1);
+
+    let res = matrix1.qr();
+    let (q, r) = res.unpack();
+
+    // Uses different algo need to match numpy
+    out_q_slice.copy_from_slice(q.transpose().as_slice());
+    out_r_slice.copy_from_slice(r.transpose().as_slice());
+}
+
+/// # Safety
+///
+/// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
+#[no_mangle]
+pub unsafe extern "C" fn np_linalg_svd(
+    mat1: *mut InputMatrix,
+    outu: *mut InputMatrix,
+    outs: *mut InputMatrix,
+    outvh: *mut InputMatrix,
+) {
+    let mat1 = mat1.as_mut().unwrap();
+    let outu = outu.as_mut().unwrap();
+    let outs = outs.as_mut().unwrap();
+    let outvh = outvh.as_mut().unwrap();
+
+    if mat1.ndims != 2 {
+        let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
+        report_error("ValueError", "np_linalg_svd", file!(), line!(), column!(), &err_msg);
+    }
+
+    let dim1 = (*mat1).get_dims();
+    let outu_dim = (*outu).get_dims();
+    let outs_dim = (*outs).get_dims();
+    let outvh_dim = (*outvh).get_dims();
+
+    let data_slice1 = unsafe { slice::from_raw_parts_mut(mat1.data, dim1[0] * dim1[1]) };
+    let out_u_slice = unsafe { slice::from_raw_parts_mut(outu.data, outu_dim[0] * outu_dim[1]) };
+    let out_s_slice = unsafe { slice::from_raw_parts_mut(outs.data, outs_dim[0]) };
+    let out_vh_slice =
+        unsafe { slice::from_raw_parts_mut(outvh.data, outvh_dim[0] * outvh_dim[1]) };
+
+    let matrix = DMatrix::from_row_slice(dim1[0], dim1[1], data_slice1);
+    let result = matrix.svd(true, true);
+    out_u_slice.copy_from_slice(result.u.unwrap().transpose().as_slice());
+    out_s_slice.copy_from_slice(result.singular_values.as_slice());
+    out_vh_slice.copy_from_slice(result.v_t.unwrap().transpose().as_slice());
+}
+
+/// # Safety
+///
+/// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
+#[no_mangle]
+pub unsafe extern "C" fn np_linalg_inv(mat1: *mut InputMatrix, out: *mut InputMatrix) {
+    let mat1 = mat1.as_mut().unwrap();
+    let out = out.as_mut().unwrap();
+
+    if mat1.ndims != 2 {
+        let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
+        report_error("ValueError", "np_linalg_inv", file!(), line!(), column!(), &err_msg);
+    }
+    let dim1 = (*mat1).get_dims();
+
+    if dim1[0] != dim1[1] {
+        let err_msg =
+            format!("last 2 dimensions of the array must be square: {0} != {1}", dim1[0], dim1[1]);
+        report_error("LinAlgError", "np_linalg_inv", file!(), line!(), column!(), &err_msg);
+    }
+
+    let outdim = out.get_dims();
+    let out_slice = unsafe { slice::from_raw_parts_mut(out.data, outdim[0] * outdim[1]) };
+    let data_slice1 = unsafe { slice::from_raw_parts_mut(mat1.data, dim1[0] * dim1[1]) };
+
+    let matrix = DMatrix::from_row_slice(dim1[0], dim1[1], data_slice1);
+    if !matrix.is_invertible() {
+        report_error(
+            "LinAlgError",
+            "np_linalg_inv",
+            file!(),
+            line!(),
+            column!(),
+            "no inverse for Singular Matrix",
+        );
+    }
+    let inv = matrix.try_inverse().unwrap();
+    out_slice.copy_from_slice(inv.transpose().as_slice());
+}
+
+/// # Safety
+///
+/// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
+#[no_mangle]
+pub unsafe extern "C" fn np_linalg_pinv(mat1: *mut InputMatrix, out: *mut InputMatrix) {
+    let mat1 = mat1.as_mut().unwrap();
+    let out = out.as_mut().unwrap();
+
+    if mat1.ndims != 2 {
+        let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
+        report_error("ValueError", "np_linalg_pinv", file!(), line!(), column!(), &err_msg);
+    }
+    let dim1 = (*mat1).get_dims();
+    let outdim = out.get_dims();
+    let out_slice = unsafe { slice::from_raw_parts_mut(out.data, outdim[0] * outdim[1]) };
+    let data_slice1 = unsafe { slice::from_raw_parts_mut(mat1.data, dim1[0] * dim1[1]) };
+
+    let matrix = DMatrix::from_row_slice(dim1[0], dim1[1], data_slice1);
+    let svd = matrix.svd(true, true);
+    let inv = svd.pseudo_inverse(1e-15);
+
+    match inv {
+        Ok(m) => {
+            out_slice.copy_from_slice(m.transpose().as_slice());
+        }
+        Err(err_msg) => {
+            report_error("LinAlgError", "np_linalg_pinv", file!(), line!(), column!(), err_msg);
+        }
+    }
+}
+
+/// # Safety
+///
+/// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
+#[no_mangle]
+pub unsafe extern "C" fn np_linalg_matrix_power(
+    mat1: *mut InputMatrix,
+    mat2: *mut InputMatrix,
+    out: *mut InputMatrix,
+) {
+    let mat1 = mat1.as_mut().unwrap();
+    let mat2 = mat2.as_mut().unwrap();
+    let out = out.as_mut().unwrap();
+
+    if mat1.ndims != 2 {
+        let err_msg = format!("expected 2D Vector Input, but received {}D", mat1.ndims);
+        report_error("ValueError", "np_linalg_matrix_power", file!(), line!(), column!(), &err_msg);
+    }
+
+    let dim1 = (*mat1).get_dims();
+    let power = unsafe { slice::from_raw_parts_mut(mat2.data, 1) };
+    let power = power[0];
+    let outdim = out.get_dims();
+    let out_slice = unsafe { slice::from_raw_parts_mut(out.data, outdim[0] * outdim[1]) };
+    let data_slice1 = unsafe { slice::from_raw_parts_mut(mat1.data, dim1[0] * dim1[1]) };
+
+    let abs_pow = power.abs();
+    let matrix1 = DMatrix::from_row_slice(dim1[0], dim1[1], data_slice1);
+    let mut result = matrix1.pow(abs_pow as u32);
+
+    if power < 0.0 {
+        if !result.is_invertible() {
+            report_error(
+                "LinAlgError",
+                "np_linalg_inv",
+                file!(),
+                line!(),
+                column!(),
+                "no inverse for Singular Matrix",
+            );
+        }
+        result = result.try_inverse().unwrap();
+    }
+    out_slice.copy_from_slice(result.transpose().as_slice());
+}
+
+/// # Safety
+///
+/// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
+#[no_mangle]
+pub unsafe extern "C" fn np_linalg_det(mat1: *mut InputMatrix, out: *mut InputMatrix) {
+    let mat1 = mat1.as_mut().unwrap();
+    let out = out.as_mut().unwrap();
+
+    if mat1.ndims != 2 {
+        let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
+        report_error("ValueError", "np_linalg_det", file!(), line!(), column!(), &err_msg);
+    }
+    let dim1 = (*mat1).get_dims();
+    let out_slice = unsafe { slice::from_raw_parts_mut(out.data, 1) };
+    let data_slice1 = unsafe { slice::from_raw_parts_mut(mat1.data, dim1[0] * dim1[1]) };
+
+    let matrix = DMatrix::from_row_slice(dim1[0], dim1[1], data_slice1);
+    if !matrix.is_square() {
+        let err_msg =
+            format!("last 2 dimensions of the array must be square: {0} != {1}", dim1[0], dim1[1]);
+        report_error("LinAlgError", "np_linalg_inv", file!(), line!(), column!(), &err_msg);
+    }
+    out_slice[0] = matrix.determinant();
+}
+
+/// # Safety
+///
+/// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
+#[no_mangle]
+pub unsafe extern "C" fn sp_linalg_lu(
+    mat1: *mut InputMatrix,
+    out_l: *mut InputMatrix,
+    out_u: *mut InputMatrix,
+) {
+    let mat1 = mat1.as_mut().unwrap();
+    let out_l = out_l.as_mut().unwrap();
+    let out_u = out_u.as_mut().unwrap();
+
+    if mat1.ndims != 2 {
+        let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
+        report_error("ValueError", "sp_linalg_lu", file!(), line!(), column!(), &err_msg);
+    }
+
+    let dim1 = (*mat1).get_dims();
+    let outl_dim = (*out_l).get_dims();
+    let outu_dim = (*out_u).get_dims();
+
+    let data_slice1 = unsafe { slice::from_raw_parts_mut(mat1.data, dim1[0] * dim1[1]) };
+    let out_l_slice = unsafe { slice::from_raw_parts_mut(out_l.data, outl_dim[0] * outl_dim[1]) };
+    let out_u_slice = unsafe { slice::from_raw_parts_mut(out_u.data, outu_dim[0] * outu_dim[1]) };
+
+    let matrix = DMatrix::from_row_slice(dim1[0], dim1[1], data_slice1);
+    let (_, l, u) = matrix.lu().unpack();
+
+    out_l_slice.copy_from_slice(l.transpose().as_slice());
+    out_u_slice.copy_from_slice(u.transpose().as_slice());
+}
+
+/// # Safety
+///
+/// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
+#[no_mangle]
+pub unsafe extern "C" fn sp_linalg_schur(
+    mat1: *mut InputMatrix,
+    out_t: *mut InputMatrix,
+    out_z: *mut InputMatrix,
+) {
+    let mat1 = mat1.as_mut().unwrap();
+    let out_t = out_t.as_mut().unwrap();
+    let out_z = out_z.as_mut().unwrap();
+
+    if mat1.ndims != 2 {
+        let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
+        report_error("ValueError", "sp_linalg_schur", file!(), line!(), column!(), &err_msg);
+    }
+
+    let dim1 = (*mat1).get_dims();
+
+    if dim1[0] != dim1[1] {
+        let err_msg =
+            format!("last 2 dimensions of the array must be square: {0} != {1}", dim1[0], dim1[1]);
+        report_error("LinAlgError", "np_linalg_schur", file!(), line!(), column!(), &err_msg);
+    }
+
+    let out_t_dim = (*out_t).get_dims();
+    let out_z_dim = (*out_z).get_dims();
+
+    let data_slice1 = unsafe { slice::from_raw_parts_mut(mat1.data, dim1[0] * dim1[1]) };
+    let out_t_slice = unsafe { slice::from_raw_parts_mut(out_t.data, out_t_dim[0] * out_t_dim[1]) };
+    let out_z_slice = unsafe { slice::from_raw_parts_mut(out_z.data, out_z_dim[0] * out_z_dim[1]) };
+
+    let matrix = DMatrix::from_row_slice(dim1[0], dim1[1], data_slice1);
+    let (z, t) = matrix.schur().unpack();
+
+    out_t_slice.copy_from_slice(t.transpose().as_slice());
+    out_z_slice.copy_from_slice(z.transpose().as_slice());
+}
+
+/// # Safety
+///
+/// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
+#[no_mangle]
+pub unsafe extern "C" fn sp_linalg_hessenberg(
+    mat1: *mut InputMatrix,
+    out_h: *mut InputMatrix,
+    out_q: *mut InputMatrix,
+) {
+    let mat1 = mat1.as_mut().unwrap();
+    let out_h = out_h.as_mut().unwrap();
+    let out_q = out_q.as_mut().unwrap();
+
+    if mat1.ndims != 2 {
+        let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
+        report_error("ValueError", "sp_linalg_hessenberg", file!(), line!(), column!(), &err_msg);
+    }
+
+    let dim1 = (*mat1).get_dims();
+
+    if dim1[0] != dim1[1] {
+        let err_msg =
+            format!("last 2 dimensions of the array must be square: {} != {}", dim1[0], dim1[1]);
+        report_error("LinAlgError", "sp_linalg_hessenberg", file!(), line!(), column!(), &err_msg);
+    }
+
+    let out_h_dim = (*out_h).get_dims();
+    let out_q_dim = (*out_q).get_dims();
+
+    let data_slice1 = unsafe { slice::from_raw_parts_mut(mat1.data, dim1[0] * dim1[1]) };
+    let out_h_slice = unsafe { slice::from_raw_parts_mut(out_h.data, out_h_dim[0] * out_h_dim[1]) };
+    let out_q_slice = unsafe { slice::from_raw_parts_mut(out_q.data, out_q_dim[0] * out_q_dim[1]) };
+
+    let matrix = DMatrix::from_row_slice(dim1[0], dim1[1], data_slice1);
+    let (q, h) = matrix.hessenberg().unpack();
+
+    out_h_slice.copy_from_slice(h.transpose().as_slice());
+    out_q_slice.copy_from_slice(q.transpose().as_slice());
+}
--- a/nac3standalone/demo/run_demo.sh
+++ b/nac3standalone/demo/run_demo.sh
@ -2,6 +2,9 @@

 set -e

+: "${DEMO_LINALG_STUB:=linalg/target/release/liblinalg.a}"
+: "${DEMO_LINALG_STUB32:=linalg/target/i686-unknown-linux-gnu/release/liblinalg.a}"
+
 if [ -z "$1" ]; then
    echo "No argument supplied"
    exit 1
@ -11,25 +14,26 @@ declare -a nac3args
 while [ $# -ge 1 ]; do
  case "$1" in
    --help)
-      echo "Usage: run_demo.sh [--help] [--out OUTFILE] [--lli] [--debug] -- [NAC3ARGS...]"
+      echo "Usage: run_demo.sh [--help] [--out OUTFILE] [--debug] [-i686] -- [NAC3ARGS...] demo"
      exit
      ;;
    --out)
      shift
      outfile="$1"
      ;;
-    --lli)
-      use_lli=1
-      ;;
    --debug)
      debug=1
      ;;
+    -i686)
+      i686=1
+      ;;
    --)
      shift
      break
      ;;
    *)
-      break
+      echo "Unrecognized argument \"$1\""
+      exit 1
      ;;
  esac
  shift
@ -50,29 +54,19 @@ else
 fi

 rm -f ./*.o ./*.bc demo
-if [ -z "$use_lli" ]; then
-  $nac3standalone "${nac3args[@]}"

+if [ -z "$i686" ]; then
+  $nac3standalone "${nac3args[@]}"
  clang -c -std=gnu11 -Wall -Wextra -O3 -o demo.o demo.c
-  clang -lm -o demo module.o demo.o
+  clang -o demo module.o demo.o $DEMO_LINALG_STUB -lm -Wl,--no-warn-search-mismatch
+else
+  $nac3standalone --triple i686-unknown-linux-gnu --target-features +sse2 "${nac3args[@]}"
+  clang -m32 -c -std=gnu11 -Wall -Wextra -O3 -msse2 -o demo.o demo.c
+  clang -m32 -o demo module.o demo.o $DEMO_LINALG_STUB32 -lm -Wl,--no-warn-search-mismatch
+fi

 if [ -z "$outfile" ]; then
  ./demo
 else
  ./demo > "$outfile"
 fi
-else
-  $nac3standalone --emit-llvm "${nac3args[@]}"
-
-  clang -c -std=gnu11 -Wall -Wextra -O3 -emit-llvm -o demo.bc demo.c
-
-  shopt -s nullglob
-  llvm-link -o nac3out.bc module*.bc main.bc
-  shopt -u nullglob
-
-  if [ -z "$outfile" ]; then
-    lli --extra-module demo.bc --extra-module irrt.bc nac3out.bc
-  else
-    lli --extra-module demo.bc --extra-module irrt.bc nac3out.bc > "$outfile"
-  fi
-fi
--- a/nac3standalone/demo/src/assignment.py
+++ b/nac3standalone/demo/src/assignment.py
@ -0,0 +1,76 @@
+@extern
+def output_int32(x: int32):
+    ...
+
+@extern
+def output_bool(x: bool):
+    ...
+
+def example1():
+    x, *ys, z = (1, 2, 3, 4, 5)
+    output_int32(x)
+    output_int32(len(ys))
+    output_int32(ys[0])
+    output_int32(ys[1])
+    output_int32(ys[2])
+    output_int32(z)
+
+def example2():
+    x, y, *zs = (1, 2, 3, 4, 5)
+    output_int32(x)
+    output_int32(y)
+    output_int32(len(zs))
+    output_int32(zs[0])
+    output_int32(zs[1])
+    output_int32(zs[2])
+
+def example3():
+    *xs, y, z = (1, 2, 3, 4, 5)
+    output_int32(len(xs))
+    output_int32(xs[0])
+    output_int32(xs[1])
+    output_int32(xs[2])
+    output_int32(y)
+    output_int32(z)
+
+def example4():
+    *xs, y, z = (4, 5)
+    output_int32(len(xs))
+    output_int32(y)
+    output_int32(z)
+
+def example5():
+    # Example from: https://docs.python.org/3/reference/simple_stmts.html#assignment-statements
+    x = [0, 1]
+    i = 0
+    i, x[i] = 1, 2 # i is updated, then x[i] is updated
+    output_int32(i)
+    output_int32(x[0])
+    output_int32(x[1])
+
+class A:
+    value: int32
+    def __init__(self):
+        self.value = 1000
+
+def example6():
+    ws = [88, 7, 8]
+    a = A()
+    x, [y, *ys, a.value], ws[0], (ws[0],) = 1, (2, False, 4, 5), 99, (6,)
+    output_int32(x)
+    output_int32(y)
+    output_bool(ys[0])
+    output_int32(ys[1])
+    output_int32(a.value)
+    output_int32(ws[0])
+    output_int32(ws[1])
+    output_int32(ws[2])
+
+def run() -> int32:
+    example1()
+    example2()
+    example3()
+    example4()
+    example5()
+    example6()
+    return 0
--- a/nac3standalone/demo/src/globals.py
+++ b/nac3standalone/demo/src/globals.py
@ -0,0 +1,31 @@
+@extern
+def output_int32(x: int32):
+    ...
+
+@extern
+def output_int64(x: int64):
+    ...
+
+X: int32 = 0
+Y = int64(1)
+
+def f():
+    global X, Y
+    X = 1
+    Y = int64(2)
+
+def run() -> int32:
+    global X, Y
+
+    output_int32(X)
+    output_int64(Y)
+    f()
+    output_int32(X)
+    output_int64(Y)
+
+    X = 0
+    Y = int64(0)
+    output_int32(X)
+    output_int64(Y)
+
+    return 0
--- a/nac3standalone/demo/src/inheritance.py
+++ b/nac3standalone/demo/src/inheritance.py
@ -10,23 +10,58 @@ class A:
    def __init__(self, a: int32):
        self.a = a
    
-    def f1(self):
-        self.f2()
-    
-    def f2(self):
+    def output_all_fields(self):
        output_int32(self.a)
    
+    def set_a(self, a: int32):
+        self.a = a
+
 class B(A):
    b: int32

    def __init__(self, b: int32):
-        self.a = b + 1
+        A.__init__(self, b + 1)
+        self.set_b(b)
+    
+    def output_parent_fields(self):
+        A.output_all_fields(self)
+
+    def output_all_fields(self):
+        A.output_all_fields(self)
+        output_int32(self.b)
+    
+    def set_b(self, b: int32):
        self.b = b

+class C(B):
+    c: int32
+
+    def __init__(self, c: int32):
+        B.__init__(self, c + 1)
+        self.c = c
+    
+    def output_parent_fields(self):
+        B.output_all_fields(self)
+
+    def output_all_fields(self):
+        B.output_all_fields(self)
+        output_int32(self.c)
+    
+    def set_c(self, c: int32):
+        self.c = c

 def run() -> int32:
-    aaa = A(5)
-    bbb = B(2)
-    aaa.f1()
-    bbb.f1()
+    ccc = C(10)
+    ccc.output_all_fields()
+    ccc.set_a(1)
+    ccc.set_b(2)
+    ccc.set_c(3)
+    ccc.output_all_fields()
+
+    bbb = B(10)
+    bbb.set_a(9)
+    bbb.set_b(8)
+    bbb.output_all_fields()
+    ccc.output_all_fields()
+
    return 0
--- a/nac3standalone/demo/src/ndarray.py
+++ b/nac3standalone/demo/src/ndarray.py
@ -114,12 +114,22 @@ def test_ndarray_ones():
    n: ndarray[float, 1] = np_ones([1])
    output_ndarray_float_1(n)

+    dim = (1,)
+    n_tup: ndarray[float, 1] = np_ones(dim)
+    output_ndarray_float_1(n_tup)
+
 def test_ndarray_full():
    n_float: ndarray[float, 1] = np_full([1], 2.0)
    output_ndarray_float_1(n_float)
    n_i32: ndarray[int32, 1] = np_full([1], 2)
    output_ndarray_int32_1(n_i32)

+    dim = (1,)
+    n_float_tup: ndarray[float, 1] = np_full(dim, 2.0)
+    output_ndarray_float_1(n_float_tup)
+    n_i32_tup: ndarray[int32, 1] = np_full(dim, 2)
+    output_ndarray_int32_1(n_i32_tup)
+
 def test_ndarray_eye():
    n: ndarray[float, 2] = np_eye(2)
    output_ndarray_float_2(n)
@ -867,6 +877,13 @@ def test_ndarray_minimum_broadcast_rhs_scalar():
    output_ndarray_float_2(min_x_zeros)
    output_ndarray_float_2(min_x_ones)

+def test_ndarray_argmin():
+    x = np_array([[1., 2.], [3., 4.]])
+    y = np_argmin(x)
+
+    output_ndarray_float_2(x)
+    output_int64(y)
+
 def test_ndarray_max():
    x = np_identity(2)
    y = np_max(x)
@ -910,6 +927,13 @@ def test_ndarray_maximum_broadcast_rhs_scalar():
    output_ndarray_float_2(max_x_zeros)
    output_ndarray_float_2(max_x_ones)

+def test_ndarray_argmax():
+    x = np_array([[1., 2.], [3., 4.]])
+    y = np_argmax(x)
+
+    output_ndarray_float_2(x)
+    output_int64(y)
+
 def test_ndarray_abs():
    x = np_identity(2)
    y = abs(x)
@ -1415,6 +1439,142 @@ def test_ndarray_nextafter_broadcast_rhs_scalar():
    output_ndarray_float_2(nextafter_x_zeros)
    output_ndarray_float_2(nextafter_x_ones)

+def test_ndarray_transpose():
+    x: ndarray[float, 2] = np_array([[1., 2., 3.], [4., 5., 6.]])
+    y = np_transpose(x)
+    z = np_transpose(y)
+
+    output_ndarray_float_2(x)
+    output_ndarray_float_2(y)
+
+def test_ndarray_reshape():
+    w: ndarray[float, 1] = np_array([1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])
+    x = np_reshape(w, (1, 2, 1, -1))
+    y = np_reshape(x, [2, -1])
+    z = np_reshape(y, 10)
+
+    x1: ndarray[int32, 1] = np_array([1, 2, 3, 4])
+    x2: ndarray[int32, 2] = np_reshape(x1, (2, 2))
+
+    output_ndarray_float_1(w)
+    output_ndarray_float_2(y)
+    output_ndarray_float_1(z)
+
+def test_ndarray_dot():
+    x1: ndarray[float, 1] = np_array([5.0, 1.0, 4.0, 2.0])
+    y1: ndarray[float, 1] = np_array([5.0, 1.0, 6.0, 6.0])
+    z1 = np_dot(x1, y1)
+
+    x2: ndarray[int32, 1] = np_array([5, 1, 4, 2])
+    y2: ndarray[int32, 1] = np_array([5, 1, 6, 6])
+    z2 = np_dot(x2, y2)
+
+    x3: ndarray[bool, 1] = np_array([True, True, True, True])
+    y3: ndarray[bool, 1] = np_array([True, True, True, True])
+    z3 = np_dot(x3, y3)
+
+    z4 = np_dot(2, 3)
+    z5 = np_dot(2., 3.)
+    z6 = np_dot(True, False)
+
+    output_float64(z1)
+    output_int32(z2)
+    output_bool(z3)
+    output_int32(z4)
+    output_float64(z5)
+    output_bool(z6)
+
+def test_ndarray_cholesky():
+    x: ndarray[float, 2] = np_array([[5.0, 1.0], [1.0, 4.0]])
+    y = np_linalg_cholesky(x)
+
+    output_ndarray_float_2(x)
+    output_ndarray_float_2(y)
+
+def test_ndarray_qr():
+    x: ndarray[float, 2] = np_array([[-5.0, -1.0, 2.0], [-1.0, 4.0, 7.5], [-1.0, 8.0, -8.5]])
+    y, z  = np_linalg_qr(x)
+
+    output_ndarray_float_2(x)
+
+    # QR Factorization is not unique and gives different results in numpy and nalgebra
+    # Reverting the decomposition to compare the initial arrays
+    a = y @ z
+    output_ndarray_float_2(a)
+
+def test_ndarray_linalg_inv():
+    x: ndarray[float, 2] = np_array([[-5.0, -1.0, 2.0], [-1.0, 4.0, 7.5], [-1.0, 8.0, -8.5]])
+    y = np_linalg_inv(x)
+
+    output_ndarray_float_2(x)
+    output_ndarray_float_2(y)
+
+def test_ndarray_pinv():
+    x: ndarray[float, 2] = np_array([[-5.0, -1.0, 2.0], [-1.0, 4.0, 7.5]])
+    y = np_linalg_pinv(x)
+
+    output_ndarray_float_2(x)
+    output_ndarray_float_2(y)
+
+def test_ndarray_matrix_power():
+    x: ndarray[float, 2] = np_array([[-5.0, -1.0, 2.0], [-1.0, 4.0, 7.5], [-1.0, 8.0, -8.5]])
+    y = np_linalg_matrix_power(x, -9)
+
+    output_ndarray_float_2(x)
+    output_ndarray_float_2(y)
+
+def test_ndarray_det():
+    x: ndarray[float, 2] = np_array([[-5.0, -1.0, 2.0], [-1.0, 4.0, 7.5], [-1.0, 8.0, -8.5]])
+    y = np_linalg_det(x)
+
+    output_ndarray_float_2(x)
+    output_float64(y)
+
+def test_ndarray_schur():
+    x: ndarray[float, 2] = np_array([[-5.0, -1.0, 2.0], [-1.0, 4.0, 7.5], [-1.0, 8.0, -8.5]])
+    t, z = sp_linalg_schur(x)
+
+    output_ndarray_float_2(x)
+
+    # Schur Factorization is not unique and gives different results in scipy and nalgebra
+    # Reverting the decomposition to compare the initial arrays
+    a = (z @ t) @ np_linalg_inv(z)
+    output_ndarray_float_2(a)
+
+def test_ndarray_hessenberg():
+    x: ndarray[float, 2] = np_array([[-5.0, -1.0, 2.0], [-1.0, 4.0, 7.5], [-1.0, 5.0, 8.5]])
+    h, q = sp_linalg_hessenberg(x)
+
+    output_ndarray_float_2(x)
+
+    # Hessenberg Factorization is not unique and gives different results in scipy and nalgebra
+    # Reverting the decomposition to compare the initial arrays
+    a = (q @ h) @ np_linalg_inv(q)
+    output_ndarray_float_2(a)
+
+
+def test_ndarray_lu():
+    x: ndarray[float, 2] = np_array([[-5.0, -1.0, 2.0], [-1.0, 4.0, 7.5]])
+    l, u = sp_linalg_lu(x)
+
+    output_ndarray_float_2(x)
+    output_ndarray_float_2(l)
+    output_ndarray_float_2(u)
+
+
+def test_ndarray_svd():
+    w: ndarray[float, 2] = np_array([[-5.0, -1.0, 2.0], [-1.0, 4.0, 7.5], [-1.0, 8.0, -8.5]])
+    x, y, z = np_linalg_svd(w)
+
+    output_ndarray_float_2(w)
+
+    # SVD Factorization is not unique and gives different results in numpy and nalgebra
+    # Reverting the decomposition to compare the initial arrays
+    a = x @ z
+    output_ndarray_float_2(a)
+    output_ndarray_float_1(y)
+
+
 def run() -> int32:
    test_ndarray_ctor()
    test_ndarray_empty()
@ -1519,16 +1679,19 @@ def run() -> int32:

    test_ndarray_round()
    test_ndarray_floor()
+    test_ndarray_ceil()
    test_ndarray_min()
    test_ndarray_minimum()
    test_ndarray_minimum_broadcast()
    test_ndarray_minimum_broadcast_lhs_scalar()
    test_ndarray_minimum_broadcast_rhs_scalar()
+    test_ndarray_argmin()
    test_ndarray_max()
    test_ndarray_maximum()
    test_ndarray_maximum_broadcast()
    test_ndarray_maximum_broadcast_lhs_scalar()
    test_ndarray_maximum_broadcast_rhs_scalar()
+    test_ndarray_argmax()
    test_ndarray_abs()
    test_ndarray_isnan()
    test_ndarray_isinf()
@ -1591,5 +1754,18 @@ def run() -> int32:
    test_ndarray_nextafter_broadcast()
    test_ndarray_nextafter_broadcast_lhs_scalar()
    test_ndarray_nextafter_broadcast_rhs_scalar()
+    test_ndarray_transpose()
+    test_ndarray_reshape()
    
+    test_ndarray_dot()
+    test_ndarray_cholesky()
+    test_ndarray_qr()
+    test_ndarray_svd()
+    test_ndarray_linalg_inv()
+    test_ndarray_pinv()
+    test_ndarray_matrix_power()
+    test_ndarray_det()
+    test_ndarray_lu()
+    test_ndarray_schur()
+    test_ndarray_hessenberg()
    return 0
--- a/nac3standalone/demo/src/str.py
+++ b/nac3standalone/demo/src/str.py
@ -0,0 +1,30 @@
+@extern
+def output_bool(x: bool):
+    ...
+
+
+def str_eq():
+    output_bool("" == "")
+    output_bool("a" == "")
+    output_bool("a" == "b")
+    output_bool("b" == "a")
+    output_bool("a" == "a")
+    output_bool("test string" == "test string")
+    output_bool("test string1" == "test string2")
+
+
+def str_ne():
+    output_bool("" != "")
+    output_bool("a" != "")
+    output_bool("a" != "b")
+    output_bool("b" != "a")
+    output_bool("a" != "a")
+    output_bool("test string" != "test string")
+    output_bool("test string1" != "test string2")
+
+
+def run() -> int32:
+    str_eq()
+    str_ne()
+
+    return 0
--- a/nac3standalone/demo/src/tuple.py
+++ b/nac3standalone/demo/src/tuple.py
@ -1,3 +1,7 @@
+@extern
+def output_bool(b: bool):
+    ...
+
@extern
 def output_int32_list(x: list[int32]):
    ...
@ -13,6 +17,41 @@ class A:
        self.a = a
        self.b = b

+
+def test_tuple_eq():
+    # 0-len
+    output_bool(() == ())
+    # 1-len
+    output_bool((1,) == ())
+    output_bool(() == (1,))
+    output_bool((1,) == (1,))
+    output_bool((1,) == (2,))
+    # # 2-len
+    output_bool((1, 2) == ())
+    output_bool(() == (1, 2))
+    output_bool((1,) == (1, 2))
+    output_bool((1, 2) == (1,))
+    output_bool((2, 2) == (1, 2))
+    output_bool((1, 2) == (2, 2))
+
+
+def test_tuple_ne():
+    # 0-len
+    output_bool(() != ())
+    # 1-len
+    output_bool((1,) != ())
+    output_bool(() != (1,))
+    output_bool((1,) != (1,))
+    output_bool((1,) != (2,))
+    # 2-len
+    output_bool((1, 2) != ())
+    output_bool(() != (1, 2))
+    output_bool((1,) != (1, 2))
+    output_bool((1, 2) != (1,))
+    output_bool((2, 2) != (1, 2))
+    output_bool((1, 2) != (2, 2))
+
+
 def run() -> int32:
    data = [0, 1, 2, 3]

@ -26,4 +65,14 @@ def run() -> int32:
        output_int32(tl[0][1])
        output_int32(tl[1])

+    output_int32(len(()))
+    output_int32(len((1,)))
+    output_int32(len((1, 2)))
+    output_int32(len((1, 2, 3)))
+    output_int32(len((1, 2, 3, 4)))
+    output_int32(len((1, 2, 3, 4, 5)))
+
+    test_tuple_eq()
+    test_tuple_ne()
+
    return 0
--- a/nac3standalone/demo/src/vararg.py
+++ b/nac3standalone/demo/src/vararg.py
@ -0,0 +1,11 @@
+def f(*args: int32):
+    pass
+
+
+def run() -> int32:
+    f()
+    f(1)
+    f(1, 2)
+    f(1, 2, 3)
+
+    return 0
--- a/nac3standalone/src/basic_symbol_resolver.rs
+++ b/nac3standalone/src/basic_symbol_resolver.rs
@ -1,5 +1,14 @@
+use std::{
+    collections::{HashMap, HashSet},
+    sync::Arc,
+};
+
+use parking_lot::{Mutex, RwLock};
+
 use nac3core::{
-    codegen::CodeGenContext,
+    codegen::{CodeGenContext, CodeGenerator},
+    inkwell::{module::Linkage, values::BasicValue},
+    nac3parser::ast::{self, StrRef},
    symbol_resolver::{SymbolResolver, SymbolValue, ValueEnum},
    toplevel::{DefinitionId, TopLevelDef},
    typecheck::{
@ -7,15 +16,10 @@ use nac3core::{
        typedef::{Type, Unifier},
    },
 };
-use nac3parser::ast::{self, StrRef};
-use parking_lot::{Mutex, RwLock};
-use std::collections::HashSet;
-use std::{collections::HashMap, sync::Arc};

 pub struct ResolverInternal {
    pub id_to_type: Mutex<HashMap<StrRef, Type>>,
    pub id_to_def: Mutex<HashMap<StrRef, DefinitionId>>,
-    pub class_names: Mutex<HashMap<StrRef, Type>>,
    pub module_globals: Mutex<HashMap<StrRef, SymbolValue>>,
    pub str_store: Mutex<HashMap<String, i32>>,
 }
@ -46,20 +50,51 @@ impl SymbolResolver for Resolver {

    fn get_symbol_type(
        &self,
-        _: &mut Unifier,
+        unifier: &mut Unifier,
        _: &[Arc<RwLock<TopLevelDef>>],
-        _: &PrimitiveStore,
+        primitives: &PrimitiveStore,
        str: StrRef,
    ) -> Result<Type, String> {
-        self.0.id_to_type.lock().get(&str).copied().ok_or(format!("cannot get type of {str}"))
+        self.0
+            .id_to_type
+            .lock()
+            .get(&str)
+            .copied()
+            .or_else(|| {
+                self.0
+                    .module_globals
+                    .lock()
+                    .get(&str)
+                    .cloned()
+                    .map(|v| v.get_type(primitives, unifier))
+            })
+            .ok_or(format!("cannot get type of {str}"))
    }

    fn get_symbol_value<'ctx>(
        &self,
-        _: StrRef,
-        _: &mut CodeGenContext<'ctx, '_>,
+        str: StrRef,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        generator: &mut dyn CodeGenerator,
    ) -> Option<ValueEnum<'ctx>> {
-        unimplemented!()
+        self.0.module_globals.lock().get(&str).cloned().map(|v| {
+            ctx.module
+                .get_global(&str.to_string())
+                .unwrap_or_else(|| {
+                    let ty = v.get_type(&ctx.primitives, &mut ctx.unifier);
+
+                    let init_val = ctx.gen_symbol_val(generator, &v, ty);
+                    let llvm_ty = init_val.get_type();
+
+                    let global = ctx.module.add_global(llvm_ty, None, &str.to_string());
+                    global.set_linkage(Linkage::LinkOnceAny);
+                    global.set_initializer(&init_val);
+
+                    global
+                })
+                .as_basic_value_enum()
+                .into()
+        })
    }

    fn get_identifier_def(&self, id: StrRef) -> Result<DefinitionId, HashSet<String>> {
--- a/nac3standalone/src/main.rs
+++ b/nac3standalone/src/main.rs
@ -8,21 +8,30 @@
 #![warn(clippy::pedantic)]
 #![allow(clippy::too_many_lines, clippy::wildcard_imports)]

-use clap::Parser;
-use inkwell::{
-    memory_buffer::MemoryBuffer, passes::PassBuilderOptions, support::is_multithreaded, targets::*,
-    OptimizationLevel,
+use std::{
+    collections::{HashMap, HashSet},
+    fs,
+    num::NonZeroUsize,
+    path::Path,
+    sync::Arc,
 };
+
+use clap::Parser;
 use parking_lot::{Mutex, RwLock};
-use std::collections::HashSet;
-use std::num::NonZeroUsize;
-use std::{collections::HashMap, fs, path::Path, sync::Arc};

 use nac3core::{
    codegen::{
        concrete_type::ConcreteTypeStore, irrt::load_irrt, CodeGenLLVMOptions,
        CodeGenTargetMachineOptions, CodeGenTask, DefaultCodeGenerator, WithCall, WorkerRegistry,
    },
+    inkwell::{
+        memory_buffer::MemoryBuffer, module::Linkage, passes::PassBuilderOptions,
+        support::is_multithreaded, targets::*, OptimizationLevel,
+    },
+    nac3parser::{
+        ast::{Constant, Expr, ExprKind, StmtKind, StrRef},
+        parser,
+    },
    symbol_resolver::SymbolResolver,
    toplevel::{
        composer::{ComposerConfig, TopLevelComposer},
@ -35,13 +44,10 @@ use nac3core::{
        typedef::{FunSignature, Type, Unifier, VarMap},
    },
 };
-use nac3parser::{
-    ast::{Constant, Expr, ExprKind, StmtKind, StrRef},
-    parser,
-};
+
+use basic_symbol_resolver::*;

 mod basic_symbol_resolver;
-use basic_symbol_resolver::*;

 /// Command-line argument parser definition.
 #[derive(Parser)]
@ -113,7 +119,9 @@ fn handle_typevar_definition(
                        x,
                        HashMap::new(),
                    )?;
-                    get_type_from_type_annotation_kinds(def_list, unifier, &ty, &mut None)
+                    get_type_from_type_annotation_kinds(
+                        def_list, unifier, primitives, &ty, &mut None,
+                    )
                })
                .collect::<Result<Vec<_>, _>>()?;
            let loc = func.location;
@ -152,7 +160,7 @@ fn handle_typevar_definition(
                HashMap::new(),
            )?;
            let constraint =
-                get_type_from_type_annotation_kinds(def_list, unifier, &ty, &mut None)?;
+                get_type_from_type_annotation_kinds(def_list, unifier, primitives, &ty, &mut None)?;
            let loc = func.location;

            Ok(unifier.get_fresh_const_generic_var(constraint, Some(generic_name), Some(loc)).ty)
@ -167,46 +175,49 @@ fn handle_typevar_definition(
 fn handle_assignment_pattern(
    targets: &[Expr],
    value: &Expr,
-    resolver: &(dyn SymbolResolver + Send + Sync),
+    resolver: Arc<dyn SymbolResolver + Send + Sync>,
    internal_resolver: &ResolverInternal,
-    def_list: &[Arc<RwLock<TopLevelDef>>],
-    unifier: &mut Unifier,
-    primitives: &PrimitiveStore,
+    composer: &mut TopLevelComposer,
 ) -> Result<(), String> {
    if targets.len() == 1 {
-        match &targets[0].node {
+        let target = &targets[0];
+
+        match &target.node {
            ExprKind::Name { id, .. } => {
+                let def_list = composer.extract_def_list();
+                let unifier = &mut composer.unifier;
+                let primitives = &composer.primitives_ty;
+
                if let Ok(var) =
-                    handle_typevar_definition(value, resolver, def_list, unifier, primitives)
+                    handle_typevar_definition(value, &*resolver, &def_list, unifier, primitives)
                {
                    internal_resolver.add_id_type(*id, var);
                    Ok(())
-                } else if let Ok(val) = parse_parameter_default_value(value, resolver) {
+                } else if let Ok(val) = parse_parameter_default_value(value, &*resolver) {
                    internal_resolver.add_module_global(*id, val);
+                    let (name, def_id, _) = composer
+                        .register_top_level_var(
+                            *id,
+                            None,
+                            Some(resolver.clone()),
+                            "__main__",
+                            target.location,
+                        )
+                        .unwrap();
+                    internal_resolver.add_id_def(name, def_id);
                    Ok(())
                } else {
                    Err(format!("fails to evaluate this expression `{:?}` as a constant or generic parameter at {}",
-                        targets[0].node,
-                        targets[0].location,
+                        target.node,
+                        target.location,
                    ))
                }
            }
            ExprKind::List { elts, .. } | ExprKind::Tuple { elts, .. } => {
-                handle_assignment_pattern(
-                    elts,
-                    value,
-                    resolver,
-                    internal_resolver,
-                    def_list,
-                    unifier,
-                    primitives,
-                )?;
+                handle_assignment_pattern(elts, value, resolver, internal_resolver, composer)?;
                Ok(())
            }
-            _ => Err(format!(
-                "assignment to {:?} is not supported at {}",
-                targets[0], targets[0].location
-            )),
+            _ => Err(format!("assignment to {target:?} is not supported at {}", target.location)),
        }
    } else {
        match &value.node {
@ -216,11 +227,9 @@ fn handle_assignment_pattern(
                        handle_assignment_pattern(
                            std::slice::from_ref(tar),
                            val,
-                            resolver,
+                            resolver.clone(),
                            internal_resolver,
-                            def_list,
-                            unifier,
-                            primitives,
+                            composer,
                        )?;
                    }
                    Ok(())
@ -238,9 +247,40 @@ fn handle_assignment_pattern(
    }
 }

-fn main() {
-    const SIZE_T: u32 = usize::BITS;
+fn handle_global_var(
+    target: &Expr,
+    value: Option<&Expr>,
+    resolver: &Arc<dyn SymbolResolver + Send + Sync>,
+    internal_resolver: &ResolverInternal,
+    composer: &mut TopLevelComposer,
+) -> Result<(), String> {
+    let ExprKind::Name { id, .. } = target.node else {
+        return Err(format!(
+            "global variable declaration must be an identifier (at {})",
+            target.location,
+        ));
+    };

+    let Some(value) = value else {
+        return Err(format!("global variable `{id}` must be initialized in its definition"));
+    };
+
+    if let Ok(val) = parse_parameter_default_value(value, &**resolver) {
+        internal_resolver.add_module_global(id, val);
+        let (name, def_id, _) = composer
+            .register_top_level_var(id, None, Some(resolver.clone()), "__main__", target.location)
+            .unwrap();
+        internal_resolver.add_id_def(name, def_id);
+        Ok(())
+    } else {
+        Err(format!(
+            "failed to evaluate this expression `{:?}` as a constant at {}",
+            target.node, target.location,
+        ))
+    }
+}
+
+fn main() {
    let cli = CommandLineArgs::parse();
    let CommandLineArgs { file_name, threads, opt_level, emit_llvm, triple, mcpu, target_features } =
        cli;
@ -273,22 +313,36 @@ fn main() {
        _ => OptimizationLevel::Aggressive,
    };

+    let target_machine_options = CodeGenTargetMachineOptions {
+        triple,
+        cpu: mcpu,
+        features: target_features,
+        reloc_mode: RelocMode::PIC,
+        ..host_target_machine
+    };
+    let target_machine = target_machine_options
+        .create_target_machine(opt_level)
+        .expect("couldn't create target machine");
+
+    let context = nac3core::inkwell::context::Context::create();
+
+    let size_t =
+        context.ptr_sized_int_type(&target_machine.get_target_data(), None).get_bit_width();
+
    let program = match fs::read_to_string(file_name.clone()) {
        Ok(program) => program,
        Err(err) => {
-            println!("Cannot open input file: {err}");
-            return;
+            panic!("Cannot open input file: {err}");
        }
    };

-    let primitive: PrimitiveStore = TopLevelComposer::make_primitives(SIZE_T).0;
+    let primitive: PrimitiveStore = TopLevelComposer::make_primitives(size_t).0;
    let (mut composer, builtins_def, builtins_ty) =
-        TopLevelComposer::new(vec![], ComposerConfig::default(), SIZE_T);
+        TopLevelComposer::new(vec![], vec![], ComposerConfig::default(), size_t);

    let internal_resolver: Arc<ResolverInternal> = ResolverInternal {
        id_to_type: builtins_ty.into(),
        id_to_def: builtins_def.into(),
-        class_names: Mutex::default(),
        module_globals: Mutex::default(),
        str_store: Mutex::default(),
    }
@ -296,27 +350,41 @@ fn main() {
    let resolver =
        Arc::new(Resolver(internal_resolver.clone())) as Arc<dyn SymbolResolver + Send + Sync>;

+    // Process IRRT
+    let irrt = load_irrt(&context, resolver.as_ref());
+    if emit_llvm {
+        irrt.write_bitcode_to_path(Path::new("irrt.bc"));
+    }
+
+    // Process the Python script
    let parser_result = parser::parse_program(&program, file_name.into()).unwrap();

    for stmt in parser_result {
        match &stmt.node {
            StmtKind::Assign { targets, value, .. } => {
-                let def_list = composer.extract_def_list();
-                let unifier = &mut composer.unifier;
-                let primitives = &composer.primitives_ty;
                if let Err(err) = handle_assignment_pattern(
                    targets,
                    value,
-                    resolver.as_ref(),
+                    resolver.clone(),
                    internal_resolver.as_ref(),
-                    &def_list,
-                    unifier,
-                    primitives,
+                    &mut composer,
                ) {
-                    eprintln!("{err}");
-                    return;
+                    panic!("{err}");
                }
            }
+
+            StmtKind::AnnAssign { target, value, .. } => {
+                if let Err(err) = handle_global_var(
+                    target,
+                    value.as_ref().map(Box::as_ref),
+                    &resolver,
+                    internal_resolver.as_ref(),
+                    &mut composer,
+                ) {
+                    panic!("{err}");
+                }
+            }
+
            // allow (and ignore) "from __future__ import annotations"
            StmtKind::ImportFrom { module, names, .. }
                if module == &Some("__future__".into())
@ -371,16 +439,7 @@ fn main() {
        instance_to_stmt[""].clone()
    };

-    let llvm_options = CodeGenLLVMOptions {
-        opt_level,
-        target: CodeGenTargetMachineOptions {
-            triple,
-            cpu: mcpu,
-            features: target_features,
-            reloc_mode: RelocMode::PIC,
-            ..host_target_machine
-        },
-    };
+    let llvm_options = CodeGenLLVMOptions { opt_level, target: target_machine_options };

    let task = CodeGenTask {
        subst: Vec::default(),
@ -403,14 +462,14 @@ fn main() {
        membuffer.lock().push(buffer);
    })));
    let threads = (0..threads)
-        .map(|i| Box::new(DefaultCodeGenerator::new(format!("module{i}"), SIZE_T)))
+        .map(|i| Box::new(DefaultCodeGenerator::new(format!("module{i}"), size_t)))
        .collect();
    let (registry, handles) = WorkerRegistry::create_workers(threads, top_level, &llvm_options, &f);
    registry.add_task(task);
    registry.wait_tasks_complete(handles);

+    // Link all modules together into `main`
    let buffers = membuffers.lock();
-    let context = inkwell::context::Context::create();
    let main = context
        .create_module_from_ir(MemoryBuffer::create_from_memory_range(&buffers[0], "main"))
        .unwrap();
@ -430,25 +489,18 @@ fn main() {
        main.link_in_module(other).unwrap();
    }

-    let irrt = load_irrt(&context);
-    if emit_llvm {
-        irrt.write_bitcode_to_path(Path::new("irrt.bc"));
-    }
    main.link_in_module(irrt).unwrap();

+    // Private all functions except "run"
    let mut function_iter = main.get_first_function();
    while let Some(func) = function_iter {
        if func.count_basic_blocks() > 0 && func.get_name().to_str().unwrap() != "run" {
-            func.set_linkage(inkwell::module::Linkage::Private);
+            func.set_linkage(Linkage::Private);
        }
        function_iter = func.get_next_function();
    }

-    let target_machine = llvm_options
-        .target
-        .create_target_machine(llvm_options.opt_level)
-        .expect("couldn't create target machine");
-
+    // Optimize `main`
    let pass_options = PassBuilderOptions::create();
    pass_options.set_merge_functions(true);
    let passes = format!("default<O{}>", opt_level as u32);
@ -457,6 +509,7 @@ fn main() {
        panic!("Failed to run optimization for module `main`: {}", err.to_string());
    }

+    // Write output
    target_machine
        .write_to_file(&main, FileType::Object, Path::new("module.o"))
        .expect("couldn't write module to file");
--- a/nix/windows/PKGBUILD
+++ b/nix/windows/PKGBUILD
@ -21,6 +21,6 @@ build() {
 }

 package() {
-  mkdir -p $pkgdir/clang64/lib/python3.11/site-packages
-  cp ${srcdir}/nac3artiq.pyd $pkgdir/clang64/lib/python3.11/site-packages
+  mkdir -p $pkgdir/clang64/lib/python3.12/site-packages
+  cp ${srcdir}/nac3artiq.pyd $pkgdir/clang64/lib/python3.12/site-packages
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
occheung	979209a526	binop: expand `not` operator as loglcal not	2024-11-08 17:12:01 +08:00
David Mak	c3927d0ef6	[ast] Refactor lazy_static to LazyLock It is available in Rust 1.80 and reduces a dependency.	2024-10-30 12:29:51 +08:00
David Mak	202a902cd0	[meta] Update dependencies	2024-10-30 12:29:51 +08:00
David Mak	b6e2644391	[meta] Update cargo dependencies	2024-10-18 14:17:16 +08:00
David Mak	45cd01556b	[meta] Apply cargo fmt	2024-10-18 14:16:42 +08:00
David Mak	b6cd2a6993	[meta] Reorganize order of use declarations - Phase 3	2024-10-17 16:25:52 +08:00
David Mak	a98f33e6d1	[meta] Reorganize order of use declarations - Phase 2 Some more rules: - For module-level imports, prefer no prefix > super > crate. - Use crate instead of super if super refers to the crate-level module	2024-10-17 15:57:33 +08:00
David Mak	5839badadd	[standalone] Update globals.py with type-inferred global var	2024-10-07 20:44:08 +08:00
David Mak	56c845aac4	[standalone] Add support for registering globals without type decl	2024-10-07 20:44:06 +08:00
David Mak	65a12d9ab3	[core] Refactor registration of top-level variables	2024-10-07 17:05:48 +08:00
David Mak	9c6685fa8f	[core] typecheck/function_check: Fix lookup of defined ids in scope	2024-10-07 16:51:37 +08:00
David Mak	2bb788e4bb	[core] codegen/expr: Materialize implicit globals Required for when globals are read without the use of a global declaration.	2024-10-07 13:13:20 +08:00
David Mak	42a2f243b5	[core] typecheck: Disallow redeclaration of var shadowing global	2024-10-07 13:11:00 +08:00
David Mak	3ce2eddcdc	[core] typecheck/type_inferencer: Infer whether variables are global	2024-10-07 13:10:46 +08:00
David Mak	51bf126a32	[core] typecheck/type_inferencer: Differentiate global symbols Required for analyzing use of global symbols before global declaration.	2024-10-07 12:25:00 +08:00
David Mak	1a197c67f6	[core] toplevel/composer: Reduce lock scope while analyzing function	2024-10-05 15:53:20 +08:00
David Mak	581b2f7bb2	[standalone] Add demo for global variables	2024-10-04 13:24:30 +08:00
David Mak	746329ec5d	[standalone] Implement symbol resolution for globals	2024-10-04 13:24:30 +08:00
David Mak	e60e8e837f	[core] Add support for global statements	2024-10-04 13:24:27 +08:00
David Mak	9fdbe9695d	[core] Add generator to SymbolResolver::get_symbol_value Needed in a future commit.	2024-10-04 13:20:29 +08:00
David Mak	8065e73598	[core] toplevel/composer: Add type analysis for global variables	2024-10-04 13:20:29 +08:00
David Mak	192290889b	[core] Add IdentifierInfo Keeps track of whether an identifier refers to a global or local variable.	2024-10-04 13:20:24 +08:00
David Mak	1407553a2f	[core] Implement parsing of global variables Globals are now parsed into symbol resolver and top level definitions.	2024-10-04 13:18:29 +08:00
David Mak	c7697606e1	[core] Add TopLevelDef::Variable	2024-10-04 13:09:25 +08:00
David Mak	88d0ccbf69	[standalone] Explicit panic when encountering a compilation error Otherwise scripts will continue to execute.	2024-10-04 13:00:16 +08:00
David Mak	a43b59539c	[meta] Move variables declarations closer to where they are first used	2024-10-04 13:00:16 +08:00
David Mak	fe06b2806f	[meta] Reorganize order of use declarations Use declarations are now grouped into 4 groups: - Declarations from the standard library - Declarations from external crates - Declarations from other crates in this project - Declarations from within this module Furthermore, all use declarations are grouped together to enhance readability. super::super is also replaced by an equivalent crate:: declaration.	2024-10-04 12:52:01 +08:00
David Mak	7f6c9a25ac	[meta] Update Cargo dependencies	2024-10-04 12:52:01 +08:00
Sébastien Bourdeauducq	6c8382219f	msys2: get python via numpy dependencies	2024-09-30 14:27:30 +08:00
Sebastien Bourdeauducq	9274a7b96b	flake: update nixpkgs	2024-09-30 14:22:40 +08:00
Sébastien Bourdeauducq	d1c0fe2900	cargo: update dependencies	2024-09-30 14:14:43 +08:00
mwojcik	f2c047ba57	artiq: support async rpcs Co-authored-by: mwojcik <mw@m-labs.hk> Co-committed-by: mwojcik <mw@m-labs.hk>	2024-09-13 12:12:13 +08:00
David Mak	5e2e77a500	[meta] Bump inkwell to v0.5	2024-09-13 11:11:14 +08:00
David Mak	f3cc4702b9	[meta] Update dependencies	2024-09-13 11:11:14 +08:00
David Mak	3e92c491f5	[standalone] Add tests creating ndarrays with tuple dims	2024-09-11 15:52:43 +08:00
lyken	7f629f1579	core: fix comment in unify_call	2024-09-11 15:46:19 +08:00
lyken	5640a793e2	core: allow np_full to take tuple shapes	2024-09-11 15:46:19 +08:00
David Mak	abbaa506ad	[standalone] Remove redundant recreation of TargetMachine	2024-09-09 14:27:10 +08:00
David Mak	f3dc02d646	[meta] Apply cargo fmt	2024-09-09 14:24:52 +08:00
David Mak	ea217eaea1	[meta] Update pre-commit config Directly invoke cargo using nix develop to avoid using the system cargo.	2024-09-09 14:24:38 +08:00
Sébastien Bourdeauducq	5a34551905	allow the use of the LLVM shared library Which in turns allows working around the incompatibility of the LLVM static library with Rust link-args=-rdynamic, which produces binaries that either fail to link (OpenBSD) or segfault on startup (Linux). The year is 2024 and compiler toolchains are still a trash fire like this.	2024-09-09 11:17:31 +08:00
Sebastien Bourdeauducq	6098b1b853	fix previous commit	2024-09-06 11:32:08 +08:00
Sebastien Bourdeauducq	668ccb1c95	nac3core: expose inkwell and nac3parser	2024-09-06 11:06:26 +08:00
Sebastien Bourdeauducq	a3c624d69d	update all dependencies	2024-09-06 10:21:58 +08:00
Sébastien Bourdeauducq	bd06155f34	irrt: compatibility with pre-C23 compilers	2024-09-05 18:54:55 +08:00
David Mak	9c33c4209c	[core] Fix type of ndarray.element_type Should be the element type of the NDArray itself, not the pointer to its type.	2024-08-30 22:47:38 +08:00
Sebastien Bourdeauducq	122983f11c	flake: update dependencies	2024-08-30 14:45:38 +08:00
David Mak	71c3a65a31	[core] codegen/stmt: Fix obtaining return type of sret functions	2024-08-29 19:15:30 +08:00
David Mak	8c540d1033	[core] codegen/stmt: Add more casts for boolean types	2024-08-29 16:36:32 +08:00
David Mak	0cc60a3d33	[core] codegen/expr: Fix missing cast to i1	2024-08-29 16:36:32 +08:00
David Mak	a59c26aa99	[artiq] Fix RPC of ndarrays from host	2024-08-29 16:08:45 +08:00
David Mak	02d93b11d1	[meta] Update dependencies	2024-08-29 14:32:21 +08:00
lyken	59cad5bfe1	standalone: clang-format demo.c	2024-08-29 10:37:24 +08:00
lyken	4318f8de84	standalone: improve src/assignment.py	2024-08-29 10:33:58 +08:00
David Mak	15ac00708a	[core] Use quoted include paths instead of angled brackets This is preferred for user-defined headers.	2024-08-28 16:37:03 +08:00
lyken	c8dfdcfdea	standalone & artiq: remove class_names from resolver	2024-08-27 23:43:40 +08:00
Sébastien Bourdeauducq	600a5c8679	Revert "standalone: reformat demo.c" This reverts commit `308edb8237`.	2024-08-27 23:06:49 +08:00
lyken	22c4d25802	core/typecheck: add missing typecheck in matmul	2024-08-27 22:59:39 +08:00
lyken	308edb8237	standalone: reformat demo.c	2024-08-27 22:55:22 +08:00
lyken	9848795dcc	core/irrt: add exceptions and debug utils	2024-08-27 22:55:22 +08:00
lyken	58222feed4	core/irrt: split into headers	2024-08-27 22:55:22 +08:00
lyken	518f21d174	core/irrt: build.rs capture IR defined constants	2024-08-27 22:55:22 +08:00
lyken	e8e49684bf	core/irrt: build.rs capture IR defined types	2024-08-27 22:55:22 +08:00
lyken	b2900b4883	core/irrt: use +std=c++20 to compile To explicitly set the C++ variant and avoid inconsistencies.	2024-08-27 22:55:22 +08:00
lyken	c6dade1394	core/irrt: reformat	2024-08-27 22:55:22 +08:00
lyken	7e3fcc0845	add .clang-format	2024-08-27 22:55:22 +08:00
lyken	d3b4c60d7f	core/irrt: comment build.rs & move irrt to nac3core/irrt	2024-08-27 22:55:22 +08:00
abdul124	5b2b6db7ed	core: improve error messages	2024-08-26 18:37:55 +08:00
abdul124	15e62f467e	standalone: add tests for polymorphism	2024-08-26 18:37:55 +08:00
abdul124	2c88924ff7	core: add support for simple polymorphism	2024-08-26 18:37:55 +08:00
abdul124	a744b139ba	core: allow Call and AnnAssign in init block	2024-08-26 18:37:55 +08:00
David Mak	2b2b2dbf8f	[core] Fix resolution of exception names in raise short form Previous implementation fails as `resolver.get_identifier_def` in ARTIQ would return the exception __init__ function rather than the class. We fix this by limiting the exception class resolution to only include raise statements, and to force the exception name to always be treated as a class. Fixes #501.	2024-08-26 18:35:02 +08:00
David Mak	d9f96dab33	[core] Add codegen_unreachable	2024-08-23 13:10:55 +08:00
David Mak	c5ae0e7c36	[standalone] Add tests for tuple equality	2024-08-21 16:25:32 +08:00
David Mak	b8dab6cf7c	[standalone] Add tests for string equality	2024-08-21 16:25:32 +08:00
David Mak	4d80ba38b7	[core] codegen/expr: Implement comparison of tuples	2024-08-21 16:25:32 +08:00
David Mak	33929bda24	[core] typecheck/typedef: Add support for tuple methods	2024-08-21 16:25:32 +08:00
David Mak	a8e92212c0	[core] codegen/expr: Implement string equality	2024-08-21 16:25:32 +08:00
David Mak	908271014a	[core] typecheck/magic_methods: Add equality methods to string	2024-08-21 16:25:32 +08:00
David Mak	c407622f5c	[core] codegen/expr: Add compilation error for unsupported cmpop	2024-08-21 15:46:13 +08:00
David Mak	d7952d0629	[core] codegen/expr: Fix assertions not generated for -O0	2024-08-21 15:36:54 +08:00
David Mak	ca1395aed6	[core] codegen: Remove redundant return	2024-08-21 15:36:54 +08:00
David Mak	7799aa4987	[meta] Do not specify rev in dependency version	2024-08-21 15:36:54 +08:00
David Mak	76016a26ad	[meta] Apply clippy suggestions	2024-08-21 13:07:57 +08:00
lyken	8532bf5206	standalone: add missing test_ndarray_ceil() run	2024-08-21 11:39:00 +08:00
lyken	2cf64d8608	apply clippy comment changes	2024-08-21 11:21:10 +08:00
lyken	706759adb2	artiq: apply cargo fmt	2024-08-21 11:21:10 +08:00
lyken	b90cf2300b	core/fix: add missing lifetime in gen_for*	2024-08-21 11:05:30 +08:00
Sebastien Bourdeauducq	0fc26df29e	flake: update nixpkgs	2024-08-19 23:53:15 +08:00
David Mak	0b074c2cf2	[artiq] symbol_resolver: Set private linkage for constants	2024-08-19 14:41:43 +08:00
Sébastien Bourdeauducq	a0f6961e0e	cargo: update dependencies	2024-08-19 13:15:03 +08:00
David Mak	b1c5c2e1d4	[artiq] Fix RPC of ndarrays to host	2024-08-15 15:41:24 +08:00
David Mak	69320a6cf1	[artiq] Fix LLVM representation of strings Should be `%str` rather than `[N x i8]`.	2024-08-14 09:30:08 +08:00
David Mak	9e0601837a	core: Add compile-time feature to disable escape analysis	2024-08-14 09:29:48 +08:00
lyken	432c81a500	core: update insta after #489	2024-08-13 15:30:34 +08:00
David Mak	6beff7a268	[artiq] Implement core_log and rtio_log in terms of polymorphic_print Implementation mostly references the original implementation in Python.	2024-08-13 15:19:03 +08:00
David Mak	6ca7aecd4a	[artiq] Add core_log and rtio_log function declarations	2024-08-13 15:19:03 +08:00
David Mak	8fd7216243	[core] toplevel/composer: Add lateinit_builtins This is required for the new core_log and rtio_log functions, which take a generic type as its parameter. However, in ARTIQ builtins are initialized using one unifier and then actually used by another unifier. lateinit_builtins workaround this issue by deferring the initialization of functions requiring type variables until the actual unifier is ready.	2024-08-13 15:19:03 +08:00
David Mak	4f5e417012	[core] codegen: Add function to get format constants for integers	2024-08-13 15:19:03 +08:00
David Mak	a0614bad83	[core] codegen/expr: Make gen_string return `StructValue` So that it is clear that the value itself is returned rather than a pointer to the struct or its data.	2024-08-13 15:19:03 +08:00
David Mak	5539d144ed	[core] Add `CodeGenContext::build_in_bounds_gep_and_load` For safer accesses to `gep`-able values and faster fails.	2024-08-13 15:19:03 +08:00
David Mak	b3891b9a0d	standalone: Fix several issues post script refactoring - Add helptext for check_demos.sh - Add back support for using debug NAC3 for running tests - Output error message when argument is not recognized - Fixed last non-demo script argument being ignored - Add back SSE2 requirement to NAC3 (required for mandelbrot)	2024-08-13 15:19:03 +08:00
David Mak	6fb8939179	[meta] Update dependencies	2024-08-13 15:19:03 +08:00
lyken	973dc5041a	core/typecheck: Support tuple arg type in len()	2024-08-13 15:02:59 +08:00
David Mak	d0da688aa7	standalone: Add tuple len test	2024-08-13 15:02:59 +08:00
David Mak	12c4e1cf48	core/toplevel/builtins: Add support for len() on tuples	2024-08-13 15:02:59 +08:00
David Mak	9b988647ed	core/toplevel/builtins: Extract len() into builtin function	2024-08-13 15:02:59 +08:00
lyken	35a7cecc12	core/typecheck: fix np_array ndmin bug	2024-08-13 12:50:04 +08:00
lyken	7e3d87f841	core/codegen: fix bug in call_ceil function	2024-08-07 16:40:55 +08:00
David Mak	ac0d83ef98	standalone: Add vararg.py	2024-08-06 11:48:42 +08:00
David Mak	3ff6db1a29	core/codegen: Add va_start and va_end intrinsics	2024-08-06 11:48:42 +08:00
David Mak	d7b806afb4	core/codegen: Implement support for va_info on supported architectures	2024-08-06 11:48:40 +08:00
David Mak	fac60c3974	core/codegen: Handle vararg in function generation	2024-08-06 11:46:00 +08:00
David Mak	f5fb504a15	core/codegen/expr: Implement vararg handling in gen_call	2024-08-06 11:46:00 +08:00
David Mak	faa3bb97ad	core/typecheck/typedef: Add vararg to Unifier::stringify	2024-08-06 11:46:00 +08:00
David Mak	6a64c9d1de	core/typecheck/typedef: Add is_vararg_ctx to TTuple	2024-08-06 11:45:54 +08:00
David Mak	3dc8498202	core/typecheck/typedef: Handle vararg parameters in unify_call	2024-08-06 11:43:13 +08:00
David Mak	cbf79c5e9c	core/typecheck/typedef: Add is_vararg to FuncArg, ConcreteFuncArg	2024-08-06 11:43:13 +08:00
David Mak	b8aa17bf8c	core/toplevel/composer: Add parsing for vararg parameter	2024-08-06 10:52:24 +08:00
David Mak	f5b998cd9c	core/codegen: Remove unnecessary mut from get_llvm*_type	2024-08-06 10:52:24 +08:00
David Mak	c36f85ecb9	meta: Update dependencies	2024-08-06 10:52:24 +08:00
lyken	3a8c385e01	core/typecheck: fix missing ExprKind::Asterisk in fix_assignment_target_context	2024-08-05 19:30:48 +08:00
lyken	221de4d06a	core/codegen: add missing comment	2024-08-05 19:30:48 +08:00
lyken	fb9fe8edf2	core: reimplement assignment type inference and codegen - distinguish between setitem and getitem - allow starred assignment targets, but the assigned value would be a tuple - allow both [...] and (...) to be target lists	2024-08-05 19:30:48 +08:00
lyken	894083c6a3	core/codegen: refactor gen_{for,comprehension} to match on iter type	2024-08-05 19:30:48 +08:00
Sébastien Bourdeauducq	669c6aca6b	clean up and fix 32-bit demos	2024-08-05 19:04:25 +08:00
abdul124	63d2b49b09	core: remove np_linalg_matmul	2024-08-05 11:44:55 +08:00
abdul124	bf709889c4	standalone/demo: separate linalg functions from main workspace	2024-08-05 11:44:54 +08:00
abdul124	1c72698d02	core: add np_linalg_det and np_linalg_matrix_power functions	2024-07-31 18:02:54 +08:00
abdul124	54f883f0a5	core: implement np_dot using LLVM_IR	2024-07-31 15:53:51 +08:00
abdul124	4a6845dac6	standalone: add np.transpose and np.reshape functions	2024-07-31 13:23:07 +08:00
abdul124	00236f48bc	core: add np.transpose and np.reshape functions	2024-07-31 13:23:07 +08:00
abdul124	a3e6bb2292	core/helper: add linalg section	2024-07-31 13:23:07 +08:00
abdul124	17171065b1	standalone: link linalg at runtime	2024-07-31 13:23:07 +08:00
abdul124	540b35ec84	standalone: move linalg functions to demo	2024-07-31 13:23:05 +08:00
abdul124	4bb00c52e3	core/builtin_fns: improve error reporting	2024-07-31 13:21:31 +08:00
abdul124	faf07527cb	standalone: add runtime implementation for linalg functions	2024-07-31 13:21:28 +08:00
abdul124	d6a4d0a634	standalone: add linalg methods and tests	2024-07-29 16:48:06 +08:00
abdul124	2242c5af43	core: add linalg methods	2024-07-29 16:48:06 +08:00
David Mak	318a675ea6	standalone: Rename -m32 to -i386	2024-07-29 14:58:58 +08:00
David Mak	32e52ce198	standalone: Revert using uint32_t as slice length Turns out list and str have always been size_t.	2024-07-29 14:58:29 +08:00
Sebastien Bourdeauducq	665ca8e32d	cargo: update dependencies	2024-07-27 22:24:56 +08:00
Sebastien Bourdeauducq	12c12b1d80	flake: update nixpkgs	2024-07-27 22:22:20 +08:00
lyken	72972fa909	core/toplevel: add more numpy categories	2024-07-27 21:57:47 +08:00
lyken	142cd48594	core/toplevel: reorder PrimDef::details	2024-07-27 21:57:47 +08:00
lyken	8adfe781c5	core/toplevel: fix PrimDef method names	2024-07-27 21:57:47 +08:00
lyken	339b74161b	core/toplevel: reorganize PrimDef	2024-07-27 21:57:47 +08:00
David Mak	8c5ba37d09	standalone: Add 32-bit execution tests to check_demo.sh	2024-07-26 13:35:40 +08:00
David Mak	05a8948ff2	core: Minor cleanup to use ListValue APIs	2024-07-26 13:35:40 +08:00
David Mak	6d171ec284	core: Add label name and hooks to gen_for functions	2024-07-26 13:35:40 +08:00
David Mak	0ba68f6657	core: Set target triple and datalayout for each module Fixes an issue with inconsistent pointer sizes causing crashes.	2024-07-26 13:35:40 +08:00
David Mak	693b2a8863	core: Add support for 32-bit size_t on 64-bit targets	2024-07-26 13:35:40 +08:00
David Mak	5faeede0e5	Determine size_t using LLVM target machine	2024-07-26 13:35:38 +08:00
David Mak	266707df9d	standalone: Add support for running 32-bit binaries	2024-07-26 13:32:38 +08:00
David Mak	3d3c258756	standalone: Remove support for --lli	2024-07-26 13:32:38 +08:00
David Mak	ed1182cb24	standalone: Update format specifiers for exceptions Use platform-agnostic identifiers instead.	2024-07-26 13:32:37 +08:00
David Mak	fd025c1137	standalone: Use uint32_t for cslice length Matching the expected type of string and list slices.	2024-07-26 13:32:21 +08:00
David Mak	f139db9af9	meta: Update dependencies	2024-07-26 10:33:02 +08:00
lyken	44487b76ae	standalone: interpret_demo.py remove duplicated section	2024-07-22 17:23:35 +08:00
lyken	1332f113e8	standalone: fix interpret_demo.py comments	2024-07-22 17:06:14 +08:00
Sébastien Bourdeauducq	7632d6f72a	cargo: update dependencies	2024-07-21 11:00:25 +08:00
David Mak	4948395ca2	core/toplevel/type_annotation: Add handling for mismatching class def Primitive types only contain fields in its Type and not its TopLevelDef. This causes primitive object types to lack some fields.	2024-07-19 14:42:14 +08:00
David Mak	3db3061d99	artiq/symbol_resolver: Handle type of zero-length lists	2024-07-19 14:42:14 +08:00
David Mak	51c2175c80	core/codegen/stmt: Convert assertion values to i1	2024-07-19 14:42:14 +08:00
lyken	1a31a50b8a	standalone: fix __nac3_raise def in demo.c	2024-07-17 21:22:08 +08:00
lyken	6c10e3d056	core: cargo clippy	2024-07-12 21:18:53 +08:00
lyken	2dbc1ec659	cargo fmt	2024-07-12 21:16:38 +08:00
Sebastien Bourdeauducq	c80378063a	add np_argmin/argmax to interpret_demo environment	2024-07-12 13:27:52 +02:00
abdul124	513d30152b	core: support raise exception short form	2024-07-12 18:58:34 +08:00
abdul124	45e9360c4d	standalone: Add np_argmax and np_argmin tests	2024-07-12 18:19:56 +08:00
abdul124	2e01b77fc8	core: refactor np_max/np_min functions	2024-07-12 18:18:54 +08:00
abdul124	cea7cade51	core: add np_argmax/np_argmin functions	2024-07-12 18:18:28 +08:00