diff --git a/.gitignore b/.gitignore
index d0870c9b..8fd148a6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -164,6 +164,7 @@ data/iw5/
 data/iw6/
 data/iw7/
 data/iw8/
+data/iw9/
 data/h1/
 data/h2/
 data/s1/
diff --git a/README.md b/README.md
index 3f0a94a1..f5bf1a9f 100644
--- a/README.md
+++ b/README.md
@@ -12,6 +12,7 @@ A utility to compile & decompile IW engine game scripts.
 - **IW6** *(Call of Duty: Ghosts)* `PC` `PS3` `PS4` `Xbox 360` `Xbox One`
 - **IW7** *(Call of Duty: Infinite Warfare)* `PC` `PS4` `Xbox One`
 - **IW8** *(Call of Duty: Modern Warfare (2019) / Warzone)* `PC` `PS4` `PS5` `Xbox One` `Xbox Series X|S`
+- **IW9** *(Call of Duty: Modern Warfare II (2022) / Warzone 2)*  ***\*WIP\****
 - **S1** *(Call of Duty: Advanced Warfare)* `PC` `PS3` `PS4` `Xbox 360` `Xbox One`
 - **S2** *(Call of Duty: WWII)* `PC` `PS4` `Xbox One`
 - **S4** *(Call of Duty: Vanguard)* `PC` `PS4` `PS5` `Xbox One` `Xbox Series X|S`
diff --git a/gen/iw9/Makefile b/gen/iw9/Makefile
new file mode 100644
index 00000000..1c14c2f3
--- /dev/null
+++ b/gen/iw9/Makefile
@@ -0,0 +1,9 @@
+generate: iw9
+
+clean:
+	rm -rf ./parser.hpp
+	rm -rf ./parser.cpp
+
+iw9: parser.ypp
+	bison parser.ypp -Wcounterexamples
+	mv parser.hpp parser.cpp ../../src/iw9/xsk/
diff --git a/gen/iw9/parser.ypp b/gen/iw9/parser.ypp
new file mode 100644
index 00000000..4437b3f5
--- /dev/null
+++ b/gen/iw9/parser.ypp
@@ -0,0 +1,914 @@
+/* Copyright 2022 xensik. All rights reserved.
+//
+// Use of this source code is governed by a GNU GPLv3 license
+// that can be found in the LICENSE file.
+*/
+
+%require "3.7"
+%skeleton "lalr1.cc"
+%language "c++"
+%output "parser.cpp"
+%defines "parser.hpp"
+%define api.prefix {IW9}
+%define api.namespace {xsk::gsc::iw9}
+%define api.location.type {xsk::gsc::location}
+%define api.value.type variant
+%define api.token.constructor
+%define api.token.raw
+%define parse.assert
+%define parse.trace
+%define parse.error detailed
+%define parse.lac full
+%locations
+%lex-param   { xsk::gsc::iw9::lexer& lexer }
+%parse-param { xsk::gsc::iw9::lexer& lexer }
+%parse-param { xsk::gsc::ast::program::ptr& ast }
+
+%code requires
+{
+#ifdef _MSC_VER
+#pragma warning(disable:4065)
+#pragma warning(disable:4127)
+#endif
+#include "iw9.hpp"
+namespace xsk::gsc::iw9 { class lexer; }
+}
+
+%code top
+{
+#include "stdafx.hpp"
+#include "parser.hpp"
+#include "lexer.hpp"
+using namespace xsk::gsc;
+xsk::gsc::iw9::parser::symbol_type IW9lex(xsk::gsc::iw9::lexer& lexer);
+}
+
+%token SH_DEFINE        "#define"
+%token SH_UNDEF         "#undef"
+%token SH_IFDEF         "#ifdef"
+%token SH_IFNDEF        "#ifndef"
+%token SH_IF            "#if"
+%token SH_ELIF          "#elif"
+%token SH_ELSE          "#else"
+%token SH_ENDIF         "#endif"
+%token DEVBEGIN         "/#"
+%token DEVEND           "#/"
+%token INLINE           "#inline"
+%token INCLUDE          "#include"
+%token USINGTREE        "#using_animtree"
+%token ANIMTREE         "#animtree"
+%token ENDON            "endon"
+%token NOTIFY           "notify"
+%token WAIT             "wait"
+%token WAITTILL         "waittill"
+%token WAITTILLMATCH    "waittillmatch"
+%token WAITTILLFRAMEEND "waittillframeend"
+%token WAITFRAME        "waitframe"
+%token IF               "if"
+%token ELSE             "else"
+%token DO               "do"
+%token WHILE            "while"
+%token FOR              "for"
+%token FOREACH          "foreach"
+%token IN               "in"
+%token SWITCH           "switch"
+%token CASE             "case"
+%token DEFAULT          "default"
+%token BREAK            "break"
+%token CONTINUE         "continue"
+%token RETURN           "return"
+%token BREAKPOINT       "breakpoint"
+%token PROFBEGIN        "prof_begin"
+%token PROFEND          "prof_end"
+%token THREAD           "thread"
+%token CHILDTHREAD      "childthread"
+%token THISTHREAD       "thisthread"
+%token CALL             "call"
+%token TRUE             "true"
+%token FALSE            "false"
+%token UNDEFINED        "undefined"
+%token SIZE             "size"
+%token GAME             "game"
+%token SELF             "self"
+%token ANIM             "anim"
+%token LEVEL            "level"
+%token ISDEFINED        "isdefined"
+%token ISTRUE           "istrue"
+%token LPAREN           "("
+%token RPAREN           ")"
+%token LBRACE           "{"
+%token RBRACE           "}"
+%token LBRACKET         "["
+%token RBRACKET         "]"
+%token COMMA            ","
+%token DOT              "."
+%token DOUBLECOLON      "::"
+%token COLON            ":"
+%token SEMICOLON        ";"
+%token QMARK            "?"
+%token INCREMENT        "++"
+%token DECREMENT        "--"
+%token LSHIFT           "<<"
+%token RSHIFT           ">>"
+%token OR               "||"
+%token AND              "&&"
+%token EQUALITY         "=="
+%token INEQUALITY       "!="
+%token LESS_EQUAL       "<="
+%token GREATER_EQUAL    ">="
+%token LESS             "<"
+%token GREATER          ">"
+%token NOT              "!"
+%token COMPLEMENT       "~"
+%token ASSIGN           "="
+%token ASSIGN_ADD       "+="
+%token ASSIGN_SUB       "-="
+%token ASSIGN_MUL       "*="
+%token ASSIGN_DIV       "/="
+%token ASSIGN_MOD       "%="
+%token ASSIGN_BW_OR     "|="
+%token ASSIGN_BW_AND    "&="
+%token ASSIGN_BW_EXOR   "^="
+%token ASSIGN_RSHIFT    ">>="
+%token ASSIGN_LSHIFT    "<<="
+%token BITWISE_OR       "|"
+%token BITWISE_AND      "&"
+%token BITWISE_EXOR     "^"
+%token ADD              "+"
+%token SUB              "-"
+%token MUL              "*"
+%token DIV              "/"
+%token MOD              "%"
+%token <std::string> PATH       "path"
+%token <std::string> IDENTIFIER "identifier"
+%token <std::string> STRING     "string literal"
+%token <std::string> ISTRING    "localized string"
+%token <std::string> FLOAT      "float"
+%token <std::string> INTEGER    "integer"
+
+%type <ast::program::ptr>               program
+%type <ast::include::ptr>               include
+%type <ast::decl>                       declaration
+%type <ast::decl_usingtree::ptr>        decl_usingtree
+%type <ast::decl_constant::ptr>         decl_constant
+%type <ast::decl_thread::ptr>           decl_thread
+%type <ast::stmt>                       stmt
+%type <ast::stmt>                       stmt_or_dev
+%type <ast::stmt_list::ptr>             stmt_list
+%type <ast::stmt_list::ptr>             stmt_or_dev_list
+%type <ast::stmt_dev::ptr>              stmt_dev
+%type <ast::stmt_list::ptr>             stmt_block
+%type <ast::stmt_expr::ptr>             stmt_expr
+%type <ast::stmt_call::ptr>             stmt_call
+%type <ast::stmt_assign::ptr>           stmt_assign
+%type <ast::stmt_endon::ptr>            stmt_endon
+%type <ast::stmt_notify::ptr>           stmt_notify
+%type <ast::stmt_wait::ptr>             stmt_wait
+%type <ast::stmt_waittill::ptr>         stmt_waittill
+%type <ast::stmt_waittillmatch::ptr>    stmt_waittillmatch
+%type <ast::stmt_waittillframeend::ptr> stmt_waittillframeend
+%type <ast::stmt_waitframe::ptr>        stmt_waitframe
+%type <ast::stmt_if::ptr>               stmt_if
+%type <ast::stmt_ifelse::ptr>           stmt_ifelse
+%type <ast::stmt_while::ptr>            stmt_while
+%type <ast::stmt_dowhile::ptr>          stmt_dowhile
+%type <ast::stmt_for::ptr>              stmt_for
+%type <ast::stmt_foreach::ptr>          stmt_foreach
+%type <ast::stmt_switch::ptr>           stmt_switch
+%type <ast::stmt_case::ptr>             stmt_case
+%type <ast::stmt_default::ptr>          stmt_default
+%type <ast::stmt_break::ptr>            stmt_break
+%type <ast::stmt_continue::ptr>         stmt_continue
+%type <ast::stmt_return::ptr>           stmt_return
+%type <ast::stmt_breakpoint::ptr>       stmt_breakpoint
+%type <ast::stmt_prof_begin::ptr>       stmt_prof_begin
+%type <ast::stmt_prof_end::ptr>         stmt_prof_end
+%type <ast::expr>                       expr
+%type <ast::expr>                       expr_or_empty
+%type <ast::expr>                       expr_assign
+%type <ast::expr>                       expr_increment
+%type <ast::expr>                       expr_decrement
+%type <ast::expr>                       expr_ternary
+%type <ast::expr>                       expr_binary
+%type <ast::expr>                       expr_primitive
+%type <ast::expr_complement::ptr>       expr_complement
+%type <ast::expr_negate::ptr>           expr_negate
+%type <ast::expr_not::ptr>              expr_not
+%type <ast::expr_call::ptr>             expr_call
+%type <ast::expr_method::ptr>           expr_method
+%type <ast::call>                       expr_function
+%type <ast::call>                       expr_pointer
+%type <ast::expr_add_array::ptr>        expr_add_array
+%type <ast::expr_parameters::ptr>       expr_parameters
+%type <ast::expr_arguments::ptr>        expr_arguments
+%type <ast::expr_arguments::ptr>        expr_arguments_no_empty
+%type <ast::expr_isdefined::ptr>        expr_isdefined
+%type <ast::expr_istrue::ptr>           expr_istrue
+%type <ast::expr_reference::ptr>        expr_reference
+%type <ast::expr>                       expr_tuple
+%type <ast::expr_tuple::ptr>            expr_tuple_arguments
+%type <ast::expr>                       expr_tuple_types
+%type <ast::expr_array::ptr>            expr_array
+%type <ast::expr_field::ptr>            expr_field
+%type <ast::expr_size::ptr>             expr_size
+%type <ast::expr_paren::ptr>            expr_paren
+%type <ast::expr>                       expr_object
+%type <ast::expr_thisthread::ptr>       expr_thisthread
+%type <ast::expr_empty_array::ptr>      expr_empty_array
+%type <ast::expr_undefined::ptr>        expr_undefined
+%type <ast::expr_game::ptr>             expr_game
+%type <ast::expr_self::ptr>             expr_self
+%type <ast::expr_anim::ptr>             expr_anim
+%type <ast::expr_level::ptr>            expr_level
+%type <ast::expr_animation::ptr>        expr_animation
+%type <ast::expr_animtree::ptr>         expr_animtree
+%type <ast::expr_identifier::ptr>       expr_identifier_nosize
+%type <ast::expr_identifier::ptr>       expr_identifier
+%type <ast::expr_path::ptr>             expr_path
+%type <ast::expr_istring::ptr>          expr_istring
+%type <ast::expr_string::ptr>           expr_string
+%type <ast::expr_vector::ptr>           expr_vector
+%type <ast::expr_float::ptr>            expr_float
+%type <ast::expr_integer::ptr>          expr_integer
+%type <ast::expr_false::ptr>            expr_false
+%type <ast::expr_true::ptr>             expr_true
+
+%nonassoc SIZEOF
+%nonassoc ADD_ARRAY
+%nonassoc RBRACKET
+%nonassoc THEN
+%nonassoc ELSE
+%nonassoc INCREMENT DECREMENT
+
+%precedence TERN
+%right QMARK
+%left OR
+%left AND
+%left BITWISE_OR
+%left BITWISE_EXOR
+%left BITWISE_AND
+%left EQUALITY INEQUALITY
+%left LESS GREATER LESS_EQUAL GREATER_EQUAL
+%left LSHIFT RSHIFT
+%left ADD SUB
+%left MUL DIV MOD
+%right NOT COMPLEMENT
+
+%precedence NEG
+%precedence ANIMREF
+%precedence PREINC PREDEC
+%precedence POSTINC POSTDEC
+
+%start root
+
+%%
+
+root
+    : program { ast = std::move($1); }
+    |         { ast = std::make_unique<ast::program>(@$); }
+    ;
+
+program
+    : program inline
+        { $$ = std::move($1); }
+    | program include
+        { $$ = std::move($1); $$->includes.push_back(std::move($2)); }
+    | program declaration
+        { $$ = std::move($1); $$->declarations.push_back(std::move($2)); }
+    | inline
+        { $$ = std::make_unique<ast::program>(@$); }
+    | include
+        { $$ = std::make_unique<ast::program>(@$); $$->includes.push_back(std::move($1)); }
+    | declaration
+        { $$ = std::make_unique<ast::program>(@$); $$->declarations.push_back(std::move($1)); }
+    ;
+
+inline
+    : INLINE expr_path SEMICOLON { lexer.push_header($2->value); }
+    ;
+
+include
+    : INCLUDE expr_path SEMICOLON
+        { $$ = std::make_unique<ast::include>(@$, std::move($2)); }
+    ;
+
+declaration
+    : DEVBEGIN          { $$.as_dev_begin = std::make_unique<ast::decl_dev_begin>(@$); }
+    | DEVEND            { $$.as_dev_end = std::make_unique<ast::decl_dev_end>(@$); }
+    | decl_usingtree    { $$.as_usingtree = std::move($1); }
+    | decl_constant     { $$.as_constant = std::move($1); }
+    | decl_thread       { $$.as_thread = std::move($1); }
+    ;
+
+decl_usingtree
+    : USINGTREE LPAREN expr_string RPAREN SEMICOLON
+        { lexer.ban_header(@$); $$ = std::make_unique<ast::decl_usingtree>(@$, std::move($3)); }
+    ;
+
+decl_constant
+    : expr_identifier ASSIGN expr SEMICOLON
+        { $$ = std::make_unique<ast::decl_constant>(@$, std::move($1), std::move($3)); }
+    ;
+
+decl_thread
+    : expr_identifier LPAREN expr_parameters RPAREN stmt_block
+        { lexer.ban_header(@$); $$ = std::make_unique<ast::decl_thread>(@$, std::move($1), std::move($3), std::move($5)); }
+    ;
+
+stmt
+    : stmt_block             { $$.as_list = std::move($1); }
+    | stmt_call              { $$.as_call = std::move($1); }
+    | stmt_assign            { $$.as_assign = std::move($1); }
+    | stmt_endon             { $$.as_endon = std::move($1); }
+    | stmt_notify            { $$.as_notify = std::move($1); }
+    | stmt_wait              { $$.as_wait = std::move($1); }
+    | stmt_waittill          { $$.as_waittill = std::move($1); }
+    | stmt_waittillmatch     { $$.as_waittillmatch = std::move($1); }
+    | stmt_waittillframeend  { $$.as_waittillframeend = std::move($1); }
+    | stmt_waitframe         { $$.as_waitframe = std::move($1); }
+    | stmt_if                { $$.as_if = std::move($1); }
+    | stmt_ifelse            { $$.as_ifelse = std::move($1); }
+    | stmt_while             { $$.as_while = std::move($1); }
+    | stmt_dowhile           { $$.as_dowhile = std::move($1); }
+    | stmt_for               { $$.as_for = std::move($1); }
+    | stmt_foreach           { $$.as_foreach = std::move($1); }
+    | stmt_switch            { $$.as_switch = std::move($1); }
+    | stmt_case              { $$.as_case = std::move($1); }
+    | stmt_default           { $$.as_default = std::move($1); }
+    | stmt_break             { $$.as_break = std::move($1); }
+    | stmt_continue          { $$.as_continue = std::move($1); }
+    | stmt_return            { $$.as_return = std::move($1); }
+    | stmt_breakpoint        { $$.as_breakpoint = std::move($1); }
+    | stmt_prof_begin        { $$.as_prof_begin = std::move($1); }
+    | stmt_prof_end          { $$.as_prof_end = std::move($1); }
+    ;
+
+stmt_or_dev
+    : stmt     { $$ = std::move($1); }
+    | stmt_dev { $$.as_dev = std::move($1); }
+    ;
+
+stmt_list
+    : stmt_list stmt
+        { $$ = std::move($1); $$->list.push_back(std::move($2)); }
+    | stmt
+        { $$ = std::make_unique<ast::stmt_list>(@$); $$->list.push_back(std::move($1)); }
+    ;
+
+stmt_or_dev_list
+    : stmt_or_dev_list stmt_or_dev
+        { $$ = std::move($1); $$->list.push_back(std::move($2)); }
+    | stmt_or_dev
+        { $$ = std::make_unique<ast::stmt_list>(@$); $$->list.push_back(std::move($1)); }
+    ;
+
+stmt_dev
+    : DEVBEGIN stmt_list DEVEND { $$ = std::make_unique<ast::stmt_dev>(@$, std::move($2)); }
+    | DEVBEGIN DEVEND { $$ = std::make_unique<ast::stmt_dev>(@$, std::make_unique<ast::stmt_list>(@$)); }
+    ;
+
+stmt_block
+    : LBRACE stmt_or_dev_list RBRACE { $$ = std::move($2); }
+    | LBRACE RBRACE { $$ = std::make_unique<ast::stmt_list>(@$); }
+    ;
+
+stmt_expr
+    : expr_assign
+        { $$ = std::make_unique<ast::stmt_expr>(@$, std::move($1)); }
+    | expr_increment
+        { $$ = std::make_unique<ast::stmt_expr>(@$, std::move($1)); }
+    | expr_decrement
+        { $$ = std::make_unique<ast::stmt_expr>(@$, std::move($1)); }
+    |
+        { $$ = std::make_unique<ast::stmt_expr>(@$, std::make_unique<ast::node>(@$)); }
+    ;
+
+stmt_call
+    : expr_call SEMICOLON
+        { $$ = std::make_unique<ast::stmt_call>(@$, ast::expr(std::move($1))); }
+    | expr_method SEMICOLON
+        { $$ = std::make_unique<ast::stmt_call>(@$, ast::expr(std::move($1))); }
+    ;
+
+stmt_assign
+    : expr_assign SEMICOLON
+        { $$ = std::make_unique<ast::stmt_assign>(@$, std::move($1)); }
+    | expr_increment SEMICOLON
+        { $$ = std::make_unique<ast::stmt_assign>(@$, std::move($1)); }
+    | expr_decrement SEMICOLON
+        { $$ = std::make_unique<ast::stmt_assign>(@$, std::move($1)); }
+    ;
+
+stmt_endon
+    : expr_object ENDON LPAREN expr RPAREN SEMICOLON
+        { $$ = std::make_unique<ast::stmt_endon>(@$, std::move($1), std::move($4)); }
+    ;
+
+stmt_notify
+    : expr_object NOTIFY LPAREN expr COMMA expr_arguments_no_empty RPAREN SEMICOLON
+        { $$ = std::make_unique<ast::stmt_notify>(@$, std::move($1), std::move($4), std::move($6)); }
+    | expr_object NOTIFY LPAREN expr RPAREN SEMICOLON
+        { $$ = std::make_unique<ast::stmt_notify>(@$, std::move($1), std::move($4), std::make_unique<ast::expr_arguments>(@$)); }
+    ;
+
+stmt_wait
+    : WAIT expr SEMICOLON
+        { $$ = std::make_unique<ast::stmt_wait>(@$, std::move($2)); }
+    ;
+
+stmt_waittill
+    : expr_object WAITTILL LPAREN expr COMMA expr_arguments_no_empty RPAREN SEMICOLON
+        { $$ = std::make_unique<ast::stmt_waittill>(@$, std::move($1), std::move($4), std::move($6)); }
+    | expr_object WAITTILL LPAREN expr RPAREN SEMICOLON
+        { $$ = std::make_unique<ast::stmt_waittill>(@$, std::move($1), std::move($4), std::make_unique<ast::expr_arguments>(@$)); }
+    ;
+
+stmt_waittillmatch
+    : expr_object WAITTILLMATCH LPAREN expr COMMA expr_arguments_no_empty RPAREN SEMICOLON
+        { $$ = std::make_unique<ast::stmt_waittillmatch>(@$, std::move($1), std::move($4), std::move($6)); }
+    | expr_object WAITTILLMATCH LPAREN expr RPAREN SEMICOLON
+        { $$ = std::make_unique<ast::stmt_waittillmatch>(@$, std::move($1), std::move($4), std::make_unique<ast::expr_arguments>(@$)); }
+    ;
+
+stmt_waittillframeend
+    : WAITTILLFRAMEEND SEMICOLON
+        { $$ = std::make_unique<ast::stmt_waittillframeend>(@$); }
+    ;
+
+stmt_waitframe
+    : WAITFRAME SEMICOLON
+        { $$ = std::make_unique<ast::stmt_waitframe>(@$); }
+    | WAITFRAME LPAREN RPAREN SEMICOLON
+        { $$ = std::make_unique<ast::stmt_waitframe>(@$); }
+    ;
+
+stmt_if
+    : IF LPAREN expr RPAREN stmt %prec THEN
+        { $$ = std::make_unique<ast::stmt_if>(@$, std::move($3), std::move($5)); }
+    ;
+
+stmt_ifelse
+    : IF LPAREN expr RPAREN stmt ELSE stmt
+        { $$ = std::make_unique<ast::stmt_ifelse>(@$, std::move($3), std::move($5), std::move($7)); }
+    ;
+
+stmt_while
+    : WHILE LPAREN expr RPAREN stmt
+        { $$ = std::make_unique<ast::stmt_while>(@$, std::move($3), std::move($5)); }
+    ;
+
+stmt_dowhile
+    : DO stmt WHILE LPAREN expr RPAREN SEMICOLON
+        { $$ = std::make_unique<ast::stmt_dowhile>(@$, std::move($5), std::move($2)); }
+    ;
+
+stmt_for
+    : FOR LPAREN stmt_expr SEMICOLON expr_or_empty SEMICOLON stmt_expr RPAREN stmt
+        { $$ = std::make_unique<ast::stmt_for>(@$, ast::stmt(std::move($3)), std::move($5), ast::stmt(std::move($7)), std::move($9)); }
+    ;
+
+stmt_foreach
+    : FOREACH LPAREN expr_identifier IN expr RPAREN stmt
+        { $$ = std::make_unique<ast::stmt_foreach>(@$, ast::expr(std::move($3)), std::move($5), std::move($7)); }
+    | FOREACH LPAREN expr_identifier COMMA expr_identifier IN expr RPAREN stmt
+        { $$ = std::make_unique<ast::stmt_foreach>(@$, ast::expr(std::move($3)), ast::expr(std::move($5)), std::move($7), std::move($9)); }
+    ;
+
+stmt_switch
+    : SWITCH LPAREN expr RPAREN stmt_block
+        { $$ = std::make_unique<ast::stmt_switch>(@$, std::move($3), std::move($5)); }
+    ;
+
+stmt_case
+    : CASE expr_integer COLON
+        { $$ = std::make_unique<ast::stmt_case>(@$, ast::expr(std::move($2)), std::make_unique<ast::stmt_list>(@$)); }
+    | CASE expr_string COLON
+        { $$ = std::make_unique<ast::stmt_case>(@$, ast::expr(std::move($2)), std::make_unique<ast::stmt_list>(@$)); }
+    ;
+
+stmt_default
+    : DEFAULT COLON
+        { $$ = std::make_unique<ast::stmt_default>(@$, std::make_unique<ast::stmt_list>(@$)); }
+    ;
+
+stmt_break
+    : BREAK SEMICOLON
+        { $$ = std::make_unique<ast::stmt_break>(@$); }
+    ;
+
+stmt_continue
+    : CONTINUE SEMICOLON
+        { $$ = std::make_unique<ast::stmt_continue>(@$); }
+    ;
+
+stmt_return
+    : RETURN expr SEMICOLON
+        { $$ = std::make_unique<ast::stmt_return>(@$, std::move($2)); }
+    | RETURN SEMICOLON
+        { $$ = std::make_unique<ast::stmt_return>(@$, std::make_unique<ast::node>(@$)); }
+    ;
+
+stmt_breakpoint
+    : BREAKPOINT SEMICOLON
+        { $$ = std::make_unique<ast::stmt_breakpoint>(@$); }
+    ;
+
+stmt_prof_begin
+    : PROFBEGIN LPAREN expr_arguments RPAREN SEMICOLON
+        { $$ = std::make_unique<ast::stmt_prof_begin>(@$, std::move($3)); }
+    ;
+
+stmt_prof_end
+    : PROFEND LPAREN expr_arguments RPAREN SEMICOLON
+        { $$ = std::make_unique<ast::stmt_prof_end>(@$, std::move($3)); }
+    ;
+
+expr
+    : expr_ternary   { $$ = std::move($1); }
+    | expr_binary    { $$ = std::move($1); }
+    | expr_primitive { $$ = std::move($1); }
+    ;
+
+expr_or_empty
+    : expr           { $$ = std::move($1); }
+    |                { $$.as_node = std::make_unique<ast::node>(@$); }
+    ;
+
+expr_assign
+    : expr_tuple ASSIGN expr
+        { $$.as_node = std::make_unique<ast::expr_assign_equal>(@$, std::move($1), std::move($3)); }
+    | expr_object ASSIGN expr
+        { $$.as_node = std::make_unique<ast::expr_assign_equal>(@$, std::move($1), std::move($3)); }
+    | expr_object ASSIGN_BW_OR expr
+        { $$.as_node = std::make_unique<ast::expr_assign_bitwise_or>(@$, std::move($1), std::move($3)); }
+    | expr_object ASSIGN_BW_AND expr
+        { $$.as_node = std::make_unique<ast::expr_assign_bitwise_and>(@$, std::move($1), std::move($3)); }
+    | expr_object ASSIGN_BW_EXOR expr
+        { $$.as_node = std::make_unique<ast::expr_assign_bitwise_exor>(@$, std::move($1), std::move($3)); }
+    | expr_object ASSIGN_LSHIFT expr
+        { $$.as_node = std::make_unique<ast::expr_assign_shift_left>(@$, std::move($1),std::move( $3)); }
+    | expr_object ASSIGN_RSHIFT expr
+        { $$.as_node = std::make_unique<ast::expr_assign_shift_right>(@$, std::move($1), std::move($3)); }
+    | expr_object ASSIGN_ADD expr
+        { $$.as_node = std::make_unique<ast::expr_assign_add>(@$, std::move($1), std::move($3)); }
+    | expr_object ASSIGN_SUB expr
+        { $$.as_node = std::make_unique<ast::expr_assign_sub>(@$, std::move($1), std::move($3)); }
+    | expr_object ASSIGN_MUL expr
+        { $$.as_node = std::make_unique<ast::expr_assign_mul>(@$, std::move($1), std::move($3)); }
+    | expr_object ASSIGN_DIV expr
+        { $$.as_node = std::make_unique<ast::expr_assign_div>(@$, std::move($1), std::move($3)); }
+    | expr_object ASSIGN_MOD expr
+        { $$.as_node = std::make_unique<ast::expr_assign_mod>(@$, std::move($1), std::move($3)); }
+    ;
+
+expr_increment
+    : INCREMENT expr_object %prec PREINC
+        { $$.as_node = std::make_unique<ast::expr_increment>(@$, std::move($2), true); }
+    | expr_object INCREMENT %prec POSTINC
+        { $$.as_node = std::make_unique<ast::expr_increment>(@$, std::move($1), false); }
+    ;
+
+expr_decrement
+    : DECREMENT expr_object %prec PREDEC
+        { $$.as_node = std::make_unique<ast::expr_decrement>(@$, std::move($2), true); }
+    | expr_object DECREMENT %prec POSTDEC
+        { $$.as_node = std::make_unique<ast::expr_decrement>(@$, std::move($1), false); }
+    ;
+
+expr_ternary
+    : expr QMARK expr COLON expr %prec TERN
+        { $$.as_node = std::make_unique<ast::expr_ternary>(@$, std::move($1), std::move($3), std::move($5)); }
+    ;
+
+expr_binary
+    : expr OR expr
+        { $$.as_node = std::make_unique<ast::expr_or>(@$, std::move($1), std::move($3)); }
+    | expr AND expr
+        { $$.as_node = std::make_unique<ast::expr_and>(@$, std::move($1), std::move($3)); }
+    | expr EQUALITY expr
+        { $$.as_node = std::make_unique<ast::expr_equality>(@$, std::move($1), std::move($3)); }
+    | expr INEQUALITY expr
+        { $$.as_node = std::make_unique<ast::expr_inequality>(@$, std::move($1), std::move($3)); }
+    | expr LESS_EQUAL expr
+        { $$.as_node = std::make_unique<ast::expr_less_equal>(@$, std::move($1), std::move($3)); }
+    | expr GREATER_EQUAL expr
+        { $$.as_node = std::make_unique<ast::expr_greater_equal>(@$, std::move($1), std::move($3)); }
+    | expr LESS expr
+        { $$.as_node = std::make_unique<ast::expr_less>(@$, std::move($1), std::move($3)); }
+    | expr GREATER expr
+        { $$.as_node = std::make_unique<ast::expr_greater>(@$, std::move($1), std::move($3)); }
+    | expr BITWISE_OR expr
+        { $$.as_node = std::make_unique<ast::expr_bitwise_or>(@$, std::move($1), std::move($3)); }
+    | expr BITWISE_AND expr
+        { $$.as_node = std::make_unique<ast::expr_bitwise_and>(@$, std::move($1), std::move($3)); }
+    | expr BITWISE_EXOR expr
+        { $$.as_node = std::make_unique<ast::expr_bitwise_exor>(@$, std::move($1), std::move($3)); }
+    | expr LSHIFT expr
+        { $$.as_node = std::make_unique<ast::expr_shift_left>(@$, std::move($1), std::move($3)); }
+    | expr RSHIFT expr
+        { $$.as_node = std::make_unique<ast::expr_shift_right>(@$, std::move($1), std::move($3)); }
+    | expr ADD expr
+        { $$.as_node = std::make_unique<ast::expr_add>(@$, std::move($1), std::move($3)); }
+    | expr SUB expr
+        { $$.as_node = std::make_unique<ast::expr_sub>(@$, std::move($1), std::move($3)); }
+    | expr MUL expr
+        { $$.as_node = std::make_unique<ast::expr_mul>(@$, std::move($1), std::move($3)); }
+    | expr DIV expr
+        { $$.as_node = std::make_unique<ast::expr_div>(@$, std::move($1), std::move($3)); }
+    | expr MOD expr
+        { $$.as_node = std::make_unique<ast::expr_mod>(@$, std::move($1), std::move($3)); }
+    ;
+
+expr_primitive
+    : expr_complement       { $$.as_node = std::move($1); }
+    | expr_negate           { $$.as_node = std::move($1); }
+    | expr_not              { $$.as_node = std::move($1); }
+    | expr_call             { $$.as_node = std::move($1); }
+    | expr_method           { $$.as_node = std::move($1); }
+    | expr_add_array        { $$.as_node = std::move($1); }
+    | expr_isdefined        { $$.as_node = std::move($1); }
+    | expr_istrue           { $$.as_node = std::move($1); }
+    | expr_reference        { $$.as_node = std::move($1); }
+    | expr_array            { $$.as_node = std::move($1); }
+    | expr_field            { $$.as_node = std::move($1); }
+    | expr_size             { $$.as_node = std::move($1); }
+    | expr_paren            { $$.as_node = std::move($1); }
+    | expr_thisthread       { $$.as_node = std::move($1); }
+    | expr_empty_array      { $$.as_node = std::move($1); }
+    | expr_undefined        { $$.as_node = std::move($1); }
+    | expr_game             { $$.as_node = std::move($1); }
+    | expr_self             { $$.as_node = std::move($1); }
+    | expr_anim             { $$.as_node = std::move($1); }
+    | expr_level            { $$.as_node = std::move($1); }
+    | expr_animation        { $$.as_node = std::move($1); }
+    | expr_animtree         { $$.as_node = std::move($1); }
+    | expr_identifier       { $$.as_node = std::move($1); }
+    | expr_istring          { $$.as_node = std::move($1); }
+    | expr_string           { $$.as_node = std::move($1); }
+    | expr_vector           { $$.as_node = std::move($1); }
+    | expr_float            { $$.as_node = std::move($1); }
+    | expr_integer          { $$.as_node = std::move($1); }
+    | expr_false            { $$.as_node = std::move($1); }
+    | expr_true             { $$.as_node = std::move($1); }
+    ;
+
+expr_complement
+    : COMPLEMENT expr
+        { $$ = std::make_unique<ast::expr_complement>(@$, std::move($2)); }
+    ;
+
+expr_negate
+    : SUB expr_identifier %prec NEG
+        { $$ = std::make_unique<ast::expr_negate>(@$, ast::expr(std::move($2))); }
+    | SUB expr_paren %prec NEG
+        { $$ = std::make_unique<ast::expr_negate>(@$, ast::expr(std::move($2))); }
+    | SUB expr_array %prec NEG
+        { $$ = std::make_unique<ast::expr_negate>(@$, ast::expr(std::move($2))); }
+    | SUB expr_field %prec NEG
+        { $$ = std::make_unique<ast::expr_negate>(@$, ast::expr(std::move($2))); }
+    ;
+
+expr_not
+    : NOT expr
+        { $$ = std::make_unique<ast::expr_not>(@$, std::move($2)); }
+    ;
+
+expr_call
+    : expr_function                { $$ = std::make_unique<ast::expr_call>(@$, std::move($1)); }
+    | expr_pointer                 { $$ = std::make_unique<ast::expr_call>(@$, std::move($1)); }
+    ;
+expr_method
+    : expr_object expr_function    { $$ = std::make_unique<ast::expr_method>(@$, std::move($1), std::move($2)); }
+    | expr_object expr_pointer     { $$ = std::make_unique<ast::expr_method>(@$, std::move($1), std::move($2)); }
+    ;
+
+expr_function
+    : expr_identifier LPAREN expr_arguments RPAREN
+        { $$.as_function = std::make_unique<ast::expr_function>(@$, std::make_unique<ast::expr_path>(@$), std::move($1), std::move($3), ast::call::mode::normal); }
+    | expr_path DOUBLECOLON expr_identifier LPAREN expr_arguments RPAREN
+        { $$.as_function = std::make_unique<ast::expr_function>(@$, std::move($1), std::move($3), std::move($5), ast::call::mode::normal); }
+    | THREAD expr_identifier LPAREN expr_arguments RPAREN
+        { $$.as_function = std::make_unique<ast::expr_function>(@$, std::make_unique<ast::expr_path>(@$), std::move($2), std::move($4), ast::call::mode::thread); }
+    | THREAD expr_path DOUBLECOLON expr_identifier LPAREN expr_arguments RPAREN
+        { $$.as_function = std::make_unique<ast::expr_function>(@$, std::move($2), std::move($4), std::move($6), ast::call::mode::thread); }
+    | CHILDTHREAD expr_identifier LPAREN expr_arguments RPAREN
+        { $$.as_function = std::make_unique<ast::expr_function>(@$, std::make_unique<ast::expr_path>(@$), std::move($2), std::move($4), ast::call::mode::childthread); }
+    | CHILDTHREAD expr_path DOUBLECOLON expr_identifier LPAREN expr_arguments RPAREN
+        { $$.as_function = std::make_unique<ast::expr_function>(@$, std::move($2), std::move($4), std::move($6), ast::call::mode::childthread); }
+    ;
+
+expr_pointer
+    : LBRACKET LBRACKET expr RBRACKET RBRACKET LPAREN expr_arguments RPAREN
+        { $$.as_pointer = std::make_unique<ast::expr_pointer>(@$, std::move($3), std::move($7), ast::call::mode::normal); }
+    | THREAD LBRACKET LBRACKET expr RBRACKET RBRACKET LPAREN expr_arguments RPAREN
+        { $$.as_pointer = std::make_unique<ast::expr_pointer>(@$, std::move($4), std::move($8), ast::call::mode::thread); }
+    | CHILDTHREAD LBRACKET LBRACKET expr RBRACKET RBRACKET LPAREN expr_arguments RPAREN
+        { $$.as_pointer = std::make_unique<ast::expr_pointer>(@$, std::move($4), std::move($8), ast::call::mode::childthread); }
+    | CALL LBRACKET LBRACKET expr RBRACKET RBRACKET LPAREN expr_arguments RPAREN
+        { $$.as_pointer = std::make_unique<ast::expr_pointer>(@$, std::move($4), std::move($8), ast::call::mode::builtin); }
+    ;
+
+expr_add_array
+    : LBRACKET expr_arguments_no_empty RBRACKET
+        { $$ = std::make_unique<ast::expr_add_array>(@$, std::move($2)); }
+    ;
+
+expr_parameters
+    : expr_parameters COMMA expr_identifier
+        { $$ = std::move($1); $$->list.push_back(std::move($3)); }
+    | expr_identifier
+        { $$ = std::make_unique<ast::expr_parameters>(@$); $$->list.push_back(std::move($1)); }
+    |
+        { $$ = std::make_unique<ast::expr_parameters>(@$); }
+    ;
+
+expr_arguments
+    : expr_arguments_no_empty
+        { $$ = std::move($1); }
+    |
+        { $$ = std::make_unique<ast::expr_arguments>(@$); }
+    ;
+
+expr_arguments_no_empty
+    : expr_arguments COMMA expr
+        { $$ = std::move($1); $$->list.push_back(std::move($3)); }
+    | expr %prec ADD_ARRAY
+        { $$ = std::make_unique<ast::expr_arguments>(@$); $$->list.push_back(std::move($1)); }
+    ;
+
+expr_isdefined
+    : ISDEFINED LPAREN expr RPAREN
+        { $$ = std::make_unique<ast::expr_isdefined>(@$, std::move($3)); }
+    ;
+
+expr_istrue
+    : ISTRUE LPAREN expr RPAREN
+        { $$ = std::make_unique<ast::expr_istrue>(@$, std::move($3)); }
+    ;
+
+expr_reference
+    : DOUBLECOLON expr_identifier
+        { $$ = std::make_unique<ast::expr_reference>(@$, std::make_unique<ast::expr_path>(@$), std::move($2)); }
+    | expr_path DOUBLECOLON expr_identifier
+        { $$ = std::make_unique<ast::expr_reference>(@$, std::move($1), std::move($3)); }
+    ;
+
+expr_tuple
+    : LBRACKET expr_tuple_arguments RBRACKET
+        { $$.as_node = std::move($2); }
+    ;
+
+expr_tuple_arguments
+    : expr_tuple_arguments COMMA expr_tuple_types
+        { $$ = std::move($1); $$->list.push_back(std::move($3)); }
+    | expr_tuple_types
+        { $$ = std::make_unique<ast::expr_tuple>(@$); $$->list.push_back(std::move($1)); }
+    ;
+
+expr_tuple_types
+    : expr_array      { $$.as_node = std::move($1); }
+    | expr_field      { $$.as_node = std::move($1); }
+    | expr_identifier { $$.as_node = std::move($1); }
+    ;
+
+expr_array
+    : expr_object LBRACKET expr RBRACKET
+        { $$ = std::make_unique<ast::expr_array>(@$, std::move($1), std::move($3)); }
+    ;
+
+expr_field
+    : expr_object DOT expr_identifier_nosize
+        { $$ = std::make_unique<ast::expr_field>(@$, std::move($1), std::move($3)); }
+    ;
+
+expr_size
+    : expr_object DOT SIZE %prec SIZEOF
+        { $$ = std::make_unique<ast::expr_size>(@$, std::move($1)); }
+    ;
+
+expr_paren
+    : LPAREN expr RPAREN
+        { $$ = std::make_unique<ast::expr_paren>(@$, std::move($2)); }
+    ;
+
+expr_object
+    : expr_call       { $$.as_node = std::move($1); }
+    | expr_method     { $$.as_node = std::move($1); }
+    | expr_array      { $$.as_node = std::move($1); }
+    | expr_field      { $$.as_node = std::move($1); }
+    | expr_game       { $$.as_node = std::move($1); }
+    | expr_self       { $$.as_node = std::move($1); }
+    | expr_anim       { $$.as_node = std::move($1); }
+    | expr_level      { $$.as_node = std::move($1); }
+    | expr_identifier { $$.as_node = std::move($1); }
+    ;
+
+expr_thisthread
+    : THISTHREAD
+        { $$ = std::make_unique<ast::expr_thisthread>(@$); };
+    ;
+
+expr_empty_array
+    : LBRACKET RBRACKET
+        { $$ = std::make_unique<ast::expr_empty_array>(@$); };
+    ;
+
+expr_undefined
+    : UNDEFINED
+        { $$ = std::make_unique<ast::expr_undefined>(@$); };
+    ;
+
+expr_game
+    : GAME
+        { $$ = std::make_unique<ast::expr_game>(@$); };
+    ;
+
+expr_self
+    : SELF
+        { $$ = std::make_unique<ast::expr_self>(@$); };
+    ;
+
+expr_anim
+    : ANIM
+        { $$ = std::make_unique<ast::expr_anim>(@$); };
+    ;
+
+expr_level
+    : LEVEL
+        { $$ = std::make_unique<ast::expr_level>(@$); };
+    ;
+
+expr_animation
+    : MOD IDENTIFIER %prec ANIMREF
+        { $$ = std::make_unique<ast::expr_animation>(@$, $2); };
+    ;
+
+expr_animtree
+    : ANIMTREE
+        { $$ = std::make_unique<ast::expr_animtree>(@$); };
+    ;
+
+expr_identifier_nosize
+    : IDENTIFIER
+        { $$ = std::make_unique<ast::expr_identifier>(@$, $1); };
+    ;
+
+expr_identifier
+    : IDENTIFIER
+        { $$ = std::make_unique<ast::expr_identifier>(@$, $1); };
+    | SIZE
+        { $$ = std::make_unique<ast::expr_identifier>(@$, "size"); };
+    ;
+
+expr_path
+    : IDENTIFIER
+        { $$ = std::make_unique<ast::expr_path>(@$, $1); };
+    | PATH
+        { $$ = std::make_unique<ast::expr_path>(@$, $1); };
+    ;
+
+expr_istring
+    : ISTRING
+        { $$ = std::make_unique<ast::expr_istring>(@$, $1); };
+    ;
+
+expr_string
+    : STRING
+        { $$ = std::make_unique<ast::expr_string>(@$, $1); };
+    ;
+
+expr_vector
+    : LPAREN expr COMMA expr COMMA expr RPAREN
+        { $$ = std::make_unique<ast::expr_vector>(@$, std::move($2), std::move($4), std::move($6)); };
+    ;
+
+expr_float
+    : SUB FLOAT %prec NEG
+        { $$ = std::make_unique<ast::expr_float>(@$, "-" + $2); };
+    | FLOAT
+        { $$ = std::make_unique<ast::expr_float>(@$, $1); };
+    ;
+
+expr_integer
+    : SUB INTEGER %prec NEG
+        { $$ = std::make_unique<ast::expr_integer>(@$, "-" + $2); };
+    | INTEGER
+        { $$ = std::make_unique<ast::expr_integer>(@$, $1); };
+    ;
+
+expr_false
+    : FALSE
+        { $$ = std::make_unique<ast::expr_false>(@$); };
+    ;
+
+expr_true
+    : TRUE
+        { $$ = std::make_unique<ast::expr_true>(@$); };
+    ;
+
+%%
+
+void xsk::gsc::iw9::parser::error(const xsk::gsc::location& loc, const std::string& msg)
+{
+    throw xsk::gsc::comp_error(loc, msg);
+}
diff --git a/premake5.lua b/premake5.lua
index 0c03f26b..e39529c4 100644
--- a/premake5.lua
+++ b/premake5.lua
@@ -57,6 +57,7 @@ project "xsk-gsc-tool"
     dependson "xsk-gsc-iw6"
     dependson "xsk-gsc-iw7"
     dependson "xsk-gsc-iw8"
+    dependson "xsk-gsc-iw9"
     dependson "xsk-gsc-s1"
     dependson "xsk-gsc-s2"
     dependson "xsk-gsc-s4"
@@ -82,6 +83,7 @@ project "xsk-gsc-tool"
         "xsk-gsc-iw6",
         "xsk-gsc-iw7",
         "xsk-gsc-iw8",
+        "xsk-gsc-iw9",
         "xsk-gsc-s1",
         "xsk-gsc-s2",
         "xsk-gsc-s4",
@@ -226,6 +228,24 @@ project "xsk-gsc-iw8"
         "./src"
     }
 
+project "xsk-gsc-iw9"
+    kind "StaticLib"
+    language "C++"
+
+    pchheader "stdafx.hpp"
+    pchsource "src/iw9/stdafx.cpp"
+
+    files {
+        "./src/iw9/**.h",
+        "./src/iw9/**.hpp",
+        "./src/iw9/**.cpp"
+    }
+
+    includedirs {
+        "./src/iw9",
+        "./src"
+    }
+
 project "xsk-gsc-s1"
     kind "StaticLib"
     language "C++"
diff --git a/src/iw9/stdafx.cpp b/src/iw9/stdafx.cpp
new file mode 100644
index 00000000..1f373bf1
--- /dev/null
+++ b/src/iw9/stdafx.cpp
@@ -0,0 +1,6 @@
+// Copyright 2022 xensik. All rights reserved.
+//
+// Use of this source code is governed by a GNU GPLv3 license
+// that can be found in the LICENSE file.
+
+#include "stdafx.hpp"
diff --git a/src/iw9/stdafx.hpp b/src/iw9/stdafx.hpp
new file mode 100644
index 00000000..19f22f43
--- /dev/null
+++ b/src/iw9/stdafx.hpp
@@ -0,0 +1,26 @@
+// Copyright 2022 xensik. All rights reserved.
+//
+// Use of this source code is governed by a GNU GPLv3 license
+// that can be found in the LICENSE file.
+
+#pragma once
+
+#include <cstdio>
+#include <algorithm>
+#include <array>
+#include <filesystem>
+#include <fstream>
+#include <functional>
+#include <iostream>
+#include <map>
+#include <memory>
+#include <regex>
+#include <set>
+#include <sstream>
+#include <stack>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+using namespace std::literals;
diff --git a/src/iw9/xsk/context.cpp b/src/iw9/xsk/context.cpp
new file mode 100644
index 00000000..6b837d4d
--- /dev/null
+++ b/src/iw9/xsk/context.cpp
@@ -0,0 +1,23 @@
+// Copyright 2022 xensik. All rights reserved.
+//
+// Use of this source code is governed by a GNU GPLv3 license
+// that can be found in the LICENSE file.
+
+#include "stdafx.hpp"
+#include "iw9.hpp"
+
+namespace xsk::gsc::iw9
+{
+
+void context::init(build mode, read_cb_type callback)
+{
+    compiler_.mode(mode);
+    resolver::init(callback);
+}
+
+void context::cleanup()
+{
+    resolver::cleanup();
+}
+
+} // namespace xsk::gsc::iw9
diff --git a/src/iw9/xsk/context.hpp b/src/iw9/xsk/context.hpp
new file mode 100644
index 00000000..6dc76419
--- /dev/null
+++ b/src/iw9/xsk/context.hpp
@@ -0,0 +1,25 @@
+// Copyright 2022 xensik. All rights reserved.
+//
+// Use of this source code is governed by a GNU GPLv3 license
+// that can be found in the LICENSE file.
+
+#pragma once
+
+namespace xsk::gsc::iw9
+{
+
+class context : public gsc::context
+{
+    iw9::disassembler disassembler_;
+
+public:
+    void init(build mode, read_cb_type callback);
+    void cleanup();
+
+    auto assembler() -> gsc::assembler& { throw std::runtime_error("not impl"); }
+    auto disassembler() -> gsc::disassembler& { return disassembler_; }
+    auto compiler() -> gsc::compiler& { throw std::runtime_error("not impl"); }
+    auto decompiler() -> gsc::decompiler& { throw std::runtime_error("not impl"); }
+};
+
+} // namespace xsk::gsc::iw9
diff --git a/src/iw9/xsk/disassembler.cpp b/src/iw9/xsk/disassembler.cpp
new file mode 100644
index 00000000..68cefc86
--- /dev/null
+++ b/src/iw9/xsk/disassembler.cpp
@@ -0,0 +1,393 @@
+// Copyright 2022 xensik. All rights reserved.
+//
+// Use of this source code is governed by a GNU GPLv3 license
+// that can be found in the LICENSE file.
+
+#include "stdafx.hpp"
+#include "iw9.hpp"
+
+namespace xsk::gsc::iw9
+{
+
+auto disassembler::output() -> std::vector<function::ptr>
+{
+    return std::move(functions_);
+}
+
+auto disassembler::output_data() -> std::vector<std::uint8_t>
+{
+    output_ = std::make_unique<utils::byte_buffer>(0x100000);
+
+    output_->write_string("// IW9 GSC ASSEMBLY\n");
+    output_->write_string("// Disassembled by https://github.com/xensik/gsc-tool\n");
+
+    for (const auto& func : functions_)
+    {
+        print_function(func);
+    }
+
+    std::vector<std::uint8_t> output;
+
+    output.resize(output_->pos());
+    std::memcpy(output.data(), output_->buffer().data(), output.size());
+
+    return output;
+}
+
+void disassembler::disassemble(const std::string& file, std::vector<std::uint8_t>& script, std::vector<std::uint8_t>& stack)
+{
+    filename_ = file;
+    script_ = std::make_unique<utils::byte_buffer>(script);
+    stack_ = std::make_unique<utils::byte_buffer>(stack);
+    functions_.clear();
+
+    script_->seek(1);
+
+    while (stack_->is_avail() && script_->is_avail())
+    {
+        functions_.push_back(std::make_unique<function>());
+        const auto& func = functions_.back();
+
+        func->index = static_cast<std::uint32_t>(script_->pos());
+        func->size = stack_->read<std::uint32_t>();
+        func->id = stack_->read<std::uint32_t>();
+        func->name = func->id == 0 ? decrypt_string(stack_->read_c_string()) : resolver::token_name(func->id);
+
+        dissasemble_function(func);
+
+        func->labels = labels_;
+        labels_.clear();
+    }
+
+    resolve_local_functions();
+}
+
+void disassembler::dissasemble_function(const function::ptr& func)
+{
+    auto size = func->size;
+
+    while (size > 0)
+    {
+        func->instructions.push_back(std::make_unique<instruction>());
+
+        const auto& inst = func->instructions.back();
+        inst->index = static_cast<std::uint32_t>(script_->pos());
+        inst->opcode = script_->read<std::uint8_t>();
+        inst->size = opcode_size(inst->opcode);
+
+        dissasemble_instruction(inst);
+
+        size -= inst->size;
+    }
+}
+
+void disassembler::dissasemble_instruction(const instruction::ptr& inst)
+{
+    switch (static_cast<opcode>(inst->opcode))
+    {
+
+        default:
+            throw disasm_error(utils::string::va("unhandled opcode 0x%X at index '%04X'!", inst->opcode, inst->index));
+    }
+}
+
+void disassembler::disassemble_builtin_call(const instruction::ptr& inst, bool method, bool args)
+{
+    if (args)
+    {
+        inst->data.push_back(utils::string::va("%i", script_->read<std::uint8_t>()));
+    }
+
+    const auto id = script_->read<std::uint16_t>();
+    const auto name = method ? resolver::method_name(id) : resolver::function_name(id);
+    inst->data.emplace(inst->data.begin(), name);
+}
+
+void disassembler::disassemble_local_call(const instruction::ptr& inst, bool thread)
+{
+    const auto offset = disassemble_offset();
+
+    inst->data.push_back(utils::string::va("%X", offset + inst->index + 1));
+
+    if (thread)
+    {
+        inst->data.push_back(utils::string::va("%i", script_->read<std::uint8_t>()));
+    }
+}
+
+void disassembler::disassemble_far_call(const instruction::ptr& inst, bool thread)
+{
+    script_->seek(3);
+
+    if (thread)
+    {
+        inst->data.push_back(utils::string::va("%i", script_->read<std::uint8_t>()));
+    }
+
+    const auto file_id = stack_->read<std::uint32_t>();
+    const auto file_name = file_id == 0 ? decrypt_string(stack_->read_c_string()) : resolver::token_name(file_id);
+    const auto func_id = stack_->read<std::uint32_t>();
+    const auto func_name = func_id == 0 ? decrypt_string(stack_->read_c_string()) : resolver::token_name(func_id);
+
+    inst->data.emplace(inst->data.begin(), func_name);
+    inst->data.emplace(inst->data.begin(), file_name);
+}
+
+void disassembler::disassemble_switch(const instruction::ptr& inst)
+{
+    const auto addr = inst->index + 4 + script_->read<std::int32_t>();
+    const auto label = utils::string::va("loc_%X", addr);
+
+    inst->data.push_back(label);
+    labels_.insert({ addr, label });
+}
+
+void disassembler::disassemble_end_switch(const instruction::ptr& inst)
+{
+    const auto count = script_->read<std::uint16_t>();
+    inst->data.push_back(utils::string::va("%i", count));
+
+    std::uint32_t index = inst->index + 3;
+
+    if (count)
+    {
+        for (auto i = count; i > 0; i--)
+        {
+            const auto value = script_->read<std::uint32_t>();
+
+            if (value < 0x100000 && value > 0)
+            {
+                inst->data.push_back("case");
+                inst->data.push_back(utils::string::quote(decrypt_string(stack_->read_c_string()), false));
+            }
+            else if (value == 0)
+            {
+                inst->data.push_back("default");
+                stack_->read_c_string(); // this should be always [0x01 0x00] unencrypted
+            }
+            else
+            {
+                inst->data.push_back("case");
+                inst->data.push_back(utils::string::va("%i", (value - 0x800000) & 0xFFFFFF));
+            }
+
+            index += 4;
+
+            const auto addr = disassemble_offset() + index;
+            const auto label = utils::string::va("loc_%X", addr);
+
+            inst->data.push_back(label);
+            labels_.insert({ addr, label });
+
+            index += 3;
+            inst->size += 7;
+        }
+    }
+}
+
+void disassembler::disassemble_field_variable(const instruction::ptr& inst)
+{
+    const auto id = script_->read<std::uint32_t>();
+    std::string name;
+
+    if (id > max_string_id)
+    {
+        auto temp = stack_->read<std::uint32_t>();
+        name = temp == 0 ? decrypt_string(stack_->read_c_string()) : std::to_string(temp);
+    }
+    else
+    {
+        name = resolver::token_name(id);
+    }
+
+    inst->data.push_back(name);
+}
+
+void disassembler::disassemble_formal_params(const instruction::ptr& inst)
+{
+    const auto count = script_->read<std::uint8_t>();
+
+    inst->size += count;
+    inst->data.push_back(utils::string::va("%i", count));
+
+    for (auto i = 0u; i < count; i++)
+    {
+        inst->data.push_back(utils::string::va("%d", script_->read<std::uint8_t>()));
+    }
+}
+
+void disassembler::disassemble_jump(const instruction::ptr& inst, bool expr, bool back)
+{
+    std::int32_t addr;
+
+    if (expr)
+    {
+        addr = inst->index + 3 + script_->read<std::int16_t>();
+    }
+    else if (back)
+    {
+        addr = inst->index + 3 - script_->read<std::uint16_t>();
+    }
+    else
+    {
+        addr = inst->index + 5 + script_->read<std::int32_t>();
+    }
+
+    const auto label = utils::string::va("loc_%X", addr);
+
+    inst->data.push_back(label);
+    labels_.insert({ addr, label });
+}
+
+auto disassembler::disassemble_offset() -> std::int32_t
+{
+    std::array<std::uint8_t, 4> bytes = {};
+
+    for (auto i = 0; i < 3; i++)
+    {
+        bytes[i] = script_->read<std::uint8_t>();
+    }
+
+    auto offset = *reinterpret_cast<std::int32_t*>(bytes.data());
+
+    offset = (offset << 8) >> 8;
+
+    return offset;
+}
+
+void disassembler::resolve_local_functions()
+{
+    for (const auto& func : functions_)
+    {
+        for (const auto& inst : func->instructions)
+        {
+            switch (static_cast<opcode>(inst->opcode))
+            {
+            /*case opcode::OP_GetLocalFunction:
+            case opcode::OP_ScriptLocalFunctionCall:
+            case opcode::OP_ScriptLocalFunctionCall2:
+            case opcode::OP_ScriptLocalMethodCall:
+            case opcode::OP_ScriptLocalThreadCall:
+            case opcode::OP_ScriptLocalChildThreadCall:
+            case opcode::OP_ScriptLocalMethodThreadCall:
+            case opcode::OP_ScriptLocalMethodChildThreadCall:
+                inst->data[0] = resolve_function(inst->data[0]);
+                break;*/
+            default:
+                break;
+            }
+        }
+    }
+}
+
+auto disassembler::resolve_function(const std::string& index) -> std::string
+{
+    if (utils::string::is_hex_number(index))
+    {
+        std::uint32_t idx = std::stoul(index, nullptr, 16);
+
+        for (const auto& func : functions_)
+        {
+            if (func->index == idx)
+            {
+                return func->name;
+            }
+        }
+
+        throw disasm_error(utils::string::va("couldn't resolve function name at index '0x%04X'!", idx));
+    }
+
+    throw disasm_error(utils::string::va("\"%s\" is not valid function address!", index.data()));
+}
+
+auto disassembler::decrypt_string(const std::string& str) -> std::string
+{
+    if (str.size() > 0 && ((static_cast<std::uint8_t>(str[0]) & 0xC0) == 0x80))
+    {
+        std::string data = "_encstr_";
+
+        for (auto i = 0u; i < str.size(); i++)
+        {
+            data = utils::string::va("%s%02X", data.data(), static_cast<std::uint8_t>(str[i]));
+        }
+
+        return data;
+    }
+
+    return str;
+}
+
+void disassembler::print_function(const function::ptr& func)
+{
+    output_->write_string("\n");
+    output_->write_string(utils::string::va("sub_%s\n", func->name.data()));
+
+    for (const auto& inst : func->instructions)
+    {
+        const auto itr = func->labels.find(inst->index);
+
+        if (itr != func->labels.end())
+        {
+            output_->write_string(utils::string::va("\t%s\n", itr->second.data()));
+        }
+
+        print_instruction(inst);
+    }
+
+    output_->write_string(utils::string::va("end_%s\n", func->name.data()));
+}
+
+void disassembler::print_instruction(const instruction::ptr& inst)
+{
+    output_->write_string(utils::string::va("\t\t%s", resolver::opcode_name(inst->opcode).data()));
+
+    switch (static_cast<opcode>(inst->opcode))
+    {
+        /*case opcode::OP_GetLocalFunction:
+        case opcode::OP_ScriptLocalFunctionCall:
+        case opcode::OP_ScriptLocalFunctionCall2:
+        case opcode::OP_ScriptLocalMethodCall:
+            output_->write_string(utils::string::va(" sub_%s", inst->data[0].data()));
+            break;
+        case opcode::OP_ScriptLocalThreadCall:
+        case opcode::OP_ScriptLocalChildThreadCall:
+        case opcode::OP_ScriptLocalMethodThreadCall:
+        case opcode::OP_ScriptLocalMethodChildThreadCall:
+            output_->write_string(utils::string::va(" sub_%s %s\n", inst->data[0].data(), inst->data[1].data()));
+            break;
+        case opcode::OP_endswitch:
+            output_->write_string(utils::string::va(" %s\n", inst->data[0].data()));
+            {
+                std::uint32_t totalcase = std::stoul(inst->data[0]);
+                auto index = 0;
+                for (auto casenum = 0u; casenum < totalcase; casenum++)
+                {
+                    if (inst->data[1 + index] == "case")
+                    {
+                        output_->write_string(utils::string::va("\t\t\t%s %s %s", inst->data[1 + index].data(), inst->data[1 + index + 1].data(), inst->data[1 + index + 2].data()));
+                        index += 3;
+                    }
+                    else if (inst->data[1 + index] == "default")
+                    {
+                        output_->write_string(utils::string::va("\t\t\t%s %s", inst->data[1 + index].data(), inst->data[1 + index + 1].data()));
+                        index += 2;
+                    }
+                    if (casenum != totalcase - 1)
+                    {
+                        output_->write_string("\n");
+                    }
+                }
+            }
+            break;*/
+        default:
+            for (auto& data : inst->data)
+            {
+                output_->write_string(utils::string::va(" %s", data.data()));
+            }
+            break;
+    }
+
+    output_->write_string("\n");
+}
+
+} // namespace xsk::gsc::iw9
diff --git a/src/iw9/xsk/disassembler.hpp b/src/iw9/xsk/disassembler.hpp
new file mode 100644
index 00000000..e6bffc15
--- /dev/null
+++ b/src/iw9/xsk/disassembler.hpp
@@ -0,0 +1,44 @@
+// Copyright 2022 xensik. All rights reserved.
+//
+// Use of this source code is governed by a GNU GPLv3 license
+// that can be found in the LICENSE file.
+
+#pragma once
+
+namespace xsk::gsc::iw9
+{
+
+class disassembler : public gsc::disassembler
+{
+    std::string filename_;
+    utils::byte_buffer::ptr script_;
+    utils::byte_buffer::ptr stack_;
+    utils::byte_buffer::ptr output_;
+    std::vector<function::ptr> functions_;
+    std::unordered_map<std::uint32_t, std::string> labels_;
+
+public:
+    auto output() -> std::vector<function::ptr>;
+    auto output_data() -> std::vector<std::uint8_t>;
+    void disassemble(const std::string& file, std::vector<std::uint8_t>& script, std::vector<std::uint8_t>& stack);
+
+private:
+    void dissasemble_function(const function::ptr& func);
+    void dissasemble_instruction(const instruction::ptr& inst);
+    void disassemble_builtin_call(const instruction::ptr& inst, bool method, bool args);
+    void disassemble_local_call(const instruction::ptr& inst, bool thread);
+    void disassemble_far_call(const instruction::ptr& inst, bool thread);
+    void disassemble_switch(const instruction::ptr& inst);
+    void disassemble_end_switch(const instruction::ptr& inst);
+    void disassemble_field_variable(const instruction::ptr& inst);
+    void disassemble_formal_params(const instruction::ptr& inst);
+    void disassemble_jump(const instruction::ptr& inst, bool expr, bool back);
+    auto disassemble_offset() -> std::int32_t;
+    void resolve_local_functions();
+    auto resolve_function(const std::string& index) -> std::string;
+    auto decrypt_string(const std::string& str) -> std::string;
+    void print_function(const function::ptr& func);
+    void print_instruction(const instruction::ptr& inst);
+};
+
+} // namespace xsk::gsc::iw9
diff --git a/src/iw9/xsk/iw9.cpp b/src/iw9/xsk/iw9.cpp
new file mode 100644
index 00000000..7e6ecd04
--- /dev/null
+++ b/src/iw9/xsk/iw9.cpp
@@ -0,0 +1,22 @@
+// Copyright 2022 xensik. All rights reserved.
+//
+// Use of this source code is governed by a GNU GPLv3 license
+// that can be found in the LICENSE file.
+
+#include "stdafx.hpp"
+#include "iw9.hpp"
+
+namespace xsk::gsc::iw9
+{
+
+auto opcode_size(std::uint8_t id) -> std::uint32_t
+{
+    switch (static_cast<opcode>(id))
+    {
+
+        default:
+            throw error("couldn't resolve instruction size for " + std::to_string(id));
+    }
+}
+
+} // namespace xsk::gsc::iw9
diff --git a/src/iw9/xsk/iw9.hpp b/src/iw9/xsk/iw9.hpp
new file mode 100644
index 00000000..91d1cc3c
--- /dev/null
+++ b/src/iw9/xsk/iw9.hpp
@@ -0,0 +1,193 @@
+// Copyright 2022 xensik. All rights reserved.
+//
+// Use of this source code is governed by a GNU GPLv3 license
+// that can be found in the LICENSE file.
+
+#pragma once
+
+#include "utils/xsk/utils.hpp"
+
+#include "disassembler.hpp"
+#include "resolver.hpp"
+#include "context.hpp"
+
+namespace xsk::gsc::iw9
+{
+
+constexpr std::uint32_t max_string_id = 0x1472F;
+
+enum class opcode : std::uint8_t
+{
+    unk_000 = 0x00,
+    unk_001 = 0x01,
+    unk_002 = 0x02,
+    unk_003 = 0x03,
+    unk_004 = 0x04,
+    unk_005 = 0x05,
+    unk_006 = 0x06,
+    unk_007 = 0x07,
+    unk_008 = 0x08,
+    unk_009 = 0x09,
+    unk_010 = 0x0A,
+    unk_011 = 0x0B,
+    unk_012 = 0x0C,
+    unk_013 = 0x0D,
+    unk_014 = 0x0E,
+    unk_015 = 0x0F,
+    unk_016 = 0x10,
+    unk_017 = 0x11,
+    unk_018 = 0x12,
+    unk_019 = 0x13,
+    unk_020 = 0x14,
+    unk_021 = 0x15,
+    unk_022 = 0x16,
+    unk_023 = 0x17,
+    unk_024 = 0x18,
+    unk_025 = 0x19,
+    unk_026 = 0x1A,
+    unk_027 = 0x1B,
+    unk_028 = 0x1C,
+    unk_029 = 0x1D,
+    unk_030 = 0x1E,
+    unk_031 = 0x1F,
+    unk_032 = 0x20,
+    unk_033 = 0x21,
+    unk_034 = 0x22,
+    unk_035 = 0x23,
+    unk_036 = 0x24,
+    unk_037 = 0x25,
+    unk_038 = 0x26,
+    unk_039 = 0x27,
+    unk_040 = 0x28,
+    unk_041 = 0x29,
+    unk_042 = 0x2A,
+    unk_043 = 0x2B,
+    unk_044 = 0x2C,
+    unk_045 = 0x2D,
+    unk_046 = 0x2E,
+    unk_047 = 0x2F,
+    unk_048 = 0x30,
+    unk_049 = 0x31,
+    unk_050 = 0x32,
+    unk_051 = 0x33,
+    unk_052 = 0x34,
+    unk_053 = 0x35,
+    unk_054 = 0x36,
+    unk_055 = 0x37,
+    unk_056 = 0x38,
+    unk_057 = 0x39,
+    unk_058 = 0x3A,
+    unk_059 = 0x3B,
+    unk_060 = 0x3C,
+    unk_061 = 0x3D,
+    unk_062 = 0x3E,
+    unk_063 = 0x3F,
+    unk_064 = 0x40,
+    unk_065 = 0x41,
+    unk_066 = 0x42,
+    unk_067 = 0x43,
+    unk_068 = 0x44,
+    unk_069 = 0x45,
+    unk_070 = 0x46,
+    unk_071 = 0x47,
+    unk_072 = 0x48,
+    unk_073 = 0x49,
+    unk_074 = 0x4A,
+    unk_075 = 0x4B,
+    unk_076 = 0x4C,
+    unk_077 = 0x4D,
+    unk_078 = 0x4E,
+    unk_079 = 0x4F,
+    unk_080 = 0x50,
+    unk_081 = 0x51,
+    unk_082 = 0x52,
+    unk_083 = 0x53,
+    unk_084 = 0x54,
+    unk_085 = 0x55,
+    unk_086 = 0x56,
+    unk_087 = 0x57,
+    unk_088 = 0x58,
+    unk_089 = 0x59,
+    unk_090 = 0x5A,
+    unk_091 = 0x5B,
+    unk_092 = 0x5C,
+    unk_093 = 0x5D,
+    unk_094 = 0x5E,
+    unk_095 = 0x5F,
+    unk_096 = 0x60,
+    unk_097 = 0x61,
+    unk_098 = 0x62,
+    unk_099 = 0x63,
+    unk_100 = 0x64,
+    unk_101 = 0x65,
+    unk_102 = 0x66,
+    unk_103 = 0x67,
+    unk_104 = 0x68,
+    unk_105 = 0x69,
+    unk_106 = 0x6A,
+    unk_107 = 0x6B,
+    unk_108 = 0x6C,
+    unk_109 = 0x6D,
+    unk_110 = 0x6E,
+    unk_111 = 0x6F,
+    unk_112 = 0x70,
+    unk_113 = 0x71,
+    unk_114 = 0x72,
+    unk_115 = 0x73,
+    unk_116 = 0x74,
+    unk_117 = 0x75,
+    unk_118 = 0x76,
+    unk_119 = 0x77,
+    unk_120 = 0x78,
+    unk_121 = 0x79,
+    unk_122 = 0x7A,
+    unk_123 = 0x7B,
+    unk_124 = 0x7C,
+    unk_125 = 0x7D,
+    unk_126 = 0x7E,
+    unk_127 = 0x7F,
+    unk_128 = 0x80,
+    unk_129 = 0x81,
+    unk_130 = 0x82,
+    unk_131 = 0x83,
+    unk_132 = 0x84,
+    unk_133 = 0x85,
+    unk_134 = 0x86,
+    unk_135 = 0x87,
+    unk_136 = 0x88,
+    unk_137 = 0x89,
+    unk_138 = 0x8A,
+    unk_139 = 0x8B,
+    unk_140 = 0x8C,
+    unk_141 = 0x8D,
+    unk_142 = 0x8E,
+    unk_143 = 0x8F,
+    unk_144 = 0x90,
+    unk_145 = 0x91,
+    unk_146 = 0x92,
+    unk_147 = 0x93,
+    unk_148 = 0x94,
+    unk_149 = 0x95,
+    unk_150 = 0x96,
+    unk_151 = 0x97,
+    unk_152 = 0x98,
+    unk_153 = 0x99,
+    unk_154 = 0x9A,
+    unk_155 = 0x9B,
+    unk_156 = 0x9C,
+    unk_157 = 0x9D,
+    unk_158 = 0x9E,
+    unk_159 = 0x9F,
+    unk_160 = 0xA0,
+    unk_161 = 0xA1,
+    unk_162 = 0xA2,
+    unk_163 = 0xA3,
+    unk_164 = 0xA4,
+    unk_165 = 0xA5,
+    unk_166 = 0xA6,
+    OP_count = 0xA7,
+};
+
+auto opcode_size(std::uint8_t op) -> std::uint32_t;
+
+} // namespace xsk::gsc::iw9
diff --git a/src/iw9/xsk/resolver.cpp b/src/iw9/xsk/resolver.cpp
new file mode 100644
index 00000000..281505ba
--- /dev/null
+++ b/src/iw9/xsk/resolver.cpp
@@ -0,0 +1,530 @@
+// Copyright 2022 xensik. All rights reserved.
+//
+// Use of this source code is governed by a GNU GPLv3 license
+// that can be found in the LICENSE file.
+
+#include "stdafx.hpp"
+#include "iw9.hpp"
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4244)
+#endif
+
+namespace xsk::gsc::iw9
+{
+
+std::unordered_map<std::uint8_t, std::string_view> opcode_map;
+std::unordered_map<std::uint16_t, std::string_view> function_map;
+std::unordered_map<std::uint16_t, std::string_view> method_map;
+std::unordered_map<std::uint32_t, std::string_view> token_map;
+std::unordered_map<std::string_view, std::uint8_t> opcode_map_rev;
+std::unordered_map<std::string_view, std::uint16_t> function_map_rev;
+std::unordered_map<std::string_view, std::uint16_t> method_map_rev;
+std::unordered_map<std::string_view, std::uint32_t> token_map_rev;
+std::unordered_map<std::string, std::vector<std::uint8_t>> files;
+read_cb_type read_callback = nullptr;
+std::set<std::string> string_map;
+
+void resolver::init(read_cb_type callback)
+{
+    read_callback = callback;
+}
+
+void resolver::cleanup()
+{
+    files.clear();
+}
+
+auto resolver::opcode_id(const std::string& name) -> std::uint8_t
+{
+    const auto itr = opcode_map_rev.find(name);
+
+    if (itr != opcode_map_rev.end())
+    {
+        return itr->second;
+    }
+
+    throw error(utils::string::va("couldn't resolve opcode id for name '%s'!", name.data()));
+}
+
+auto resolver::opcode_name(std::uint8_t id) -> std::string
+{
+    const auto itr = opcode_map.find(id);
+
+    if (itr != opcode_map.end())
+    {
+        return std::string(itr->second);
+    }
+
+    throw error(utils::string::va("couldn't resolve opcode name for id '0x%hhX'!", id));
+}
+
+auto resolver::function_id(const std::string& name) -> std::uint16_t
+{
+    if (name.starts_with("_func_"))
+    {
+        return static_cast<std::uint16_t>(std::stoul(name.substr(6), nullptr, 16));
+    }
+
+    const auto itr = function_map_rev.find(name);
+
+    if (itr != function_map_rev.end())
+    {
+        return itr->second;
+    }
+
+    throw error(utils::string::va("couldn't resolve builtin function id for name '%s'!", name.data()));
+}
+
+auto resolver::function_name(std::uint16_t id) -> std::string
+{
+    const auto itr = function_map.find(id);
+
+    if (itr != function_map.end())
+    {
+        return std::string(itr->second);
+    }
+
+    return utils::string::va("_func_%04X", id);
+}
+
+auto resolver::method_id(const std::string& name) -> std::uint16_t
+{
+    if (name.starts_with("_meth_"))
+    {
+        return static_cast<std::uint16_t>(std::stoul(name.substr(6), nullptr, 16));
+    }
+
+    const auto itr = method_map_rev.find(name);
+
+    if (itr != method_map_rev.end())
+    {
+        return itr->second;
+    }
+
+    throw error(utils::string::va("couldn't resolve builtin method id for name '%s'!", name.data()));
+}
+
+auto resolver::method_name(std::uint16_t id) -> std::string
+{
+    const auto itr = method_map.find(id);
+
+    if (itr != method_map.end())
+    {
+        return std::string(itr->second);
+    }
+
+    return utils::string::va("_meth_%04X", id);
+}
+
+auto resolver::token_id(const std::string& name) -> std::uint32_t
+{
+    if (name.starts_with("_id_"))
+    {
+        return static_cast<std::uint32_t>(std::stoul(name.substr(4), nullptr, 16));
+    }
+
+    const auto itr = token_map_rev.find(name);
+
+    if (itr != token_map_rev.end())
+    {
+        return itr->second;
+    }
+
+    return 0;
+}
+
+auto resolver::token_name(std::uint32_t id) -> std::string
+{
+    const auto itr = token_map.find(id);
+
+    if (itr != token_map.end())
+    {
+        return std::string(itr->second);
+    }
+
+    return utils::string::va("_id_%04X", id);
+}
+
+auto resolver::find_function(const std::string& name) -> bool
+{
+    if (name.starts_with("_func_")) return true;
+
+    const auto itr = function_map_rev.find(name);
+
+    if (itr != function_map_rev.end())
+    {
+        return true;
+    }
+
+    return false;
+}
+
+auto resolver::find_method(const std::string& name) -> bool
+{
+    if (name.starts_with("_meth_")) return true;
+
+    const auto itr = method_map_rev.find(name);
+
+    if (itr != method_map_rev.end())
+    {
+        return true;
+    }
+
+    return false;
+}
+
+void resolver::add_function(const std::string& name, std::uint16_t id)
+{
+    const auto itr = function_map_rev.find(name);
+
+    if (itr != function_map_rev.end())
+    {
+        throw error(utils::string::va("builtin function '%s' already defined.", name.data()));
+    }
+
+    const auto str = string_map.find(name);
+
+    if (str != string_map.end())
+    {
+        function_map.insert({ id, *str });
+        function_map_rev.insert({ *str, id });
+    }
+    else
+    {
+        auto ins = string_map.insert(name);
+
+        if (ins.second)
+        {
+            function_map.insert({ id, *ins.first });
+            function_map_rev.insert({ *ins.first, id });
+        }
+    }
+}
+
+void resolver::add_method(const std::string& name, std::uint16_t id)
+{
+    const auto itr = method_map_rev.find(name);
+
+    if (itr != method_map_rev.end())
+    {
+        throw error(utils::string::va("builtin method '%s' already defined.", name.data()));
+    }
+
+    const auto str = string_map.find(name);
+
+    if (str != string_map.end())
+    {
+        method_map.insert({ id, *str });
+        method_map_rev.insert({ *str, id });
+    }
+    else
+    {
+        auto ins = string_map.insert(name);
+
+        if (ins.second)
+        {
+            method_map.insert({ id, *ins.first });
+            method_map_rev.insert({ *ins.first, id });
+        }
+    }
+}
+
+auto resolver::make_token(std::string_view str) -> std::string
+{
+    if (str.starts_with("_id_") || str.starts_with("_func_") || str.starts_with("_meth_"))
+    {
+        return std::string(str);
+    }
+
+    auto data = std::string(str.begin(), str.end());
+
+    for (std::size_t i = 0; i < data.size(); i++)
+    {
+        data[i] = static_cast<char>(std::tolower(static_cast<unsigned char>(str[i])));
+        if (data[i] == '\\') data[i] = '/';
+    }
+
+    return data;
+}
+
+auto resolver::file_data(const std::string& name) -> std::tuple<const std::string*, const char*, size_t>
+{
+    const auto itr = files.find(name);
+
+    if (itr != files.end())
+    {
+        return { &itr->first ,reinterpret_cast<const char*>(itr->second.data()), itr->second.size() };
+    }
+
+    auto data = read_callback(name);
+
+    const auto res = files.insert({ name, std::move(data)});
+
+    if (res.second)
+    {
+        return { &res.first->first, reinterpret_cast<const char*>(res.first->second.data()), res.first->second.size() };
+    }
+
+    throw error("couldn't open gsc file '" + name + "'");
+}
+
+std::set<std::string_view> paths
+{
+};
+
+auto resolver::fs_to_game_path(const std::filesystem::path& file) -> std::filesystem::path
+{
+    auto result = std::filesystem::path();
+    auto root = false;
+
+    for (auto& entry : file)
+    {
+        if (!root && paths.contains(entry.string()))
+        {
+            result = entry;
+            root = true;
+        }
+        else if (paths.contains(result.string()))
+        {
+            result /= entry;
+        }
+    }
+
+    return result.empty() ? file : result;
+}
+
+const std::array<std::pair<std::uint8_t, const char*>, 167> opcode_list
+{{
+    { 0x00, "unk_000" },
+    { 0x01, "unk_001" },
+    { 0x02, "unk_002" },
+    { 0x03, "unk_003" },
+    { 0x04, "unk_004" },
+    { 0x05, "unk_005" },
+    { 0x06, "unk_006" },
+    { 0x07, "unk_007" },
+    { 0x08, "unk_008" },
+    { 0x09, "unk_009" },
+    { 0x0A, "unk_010" },
+    { 0x0B, "unk_011" },
+    { 0x0C, "unk_012" },
+    { 0x0D, "unk_013" },
+    { 0x0E, "unk_014" },
+    { 0x0F, "unk_015" },
+    { 0x10, "unk_016" },
+    { 0x11, "unk_017" },
+    { 0x12, "unk_018" },
+    { 0x13, "unk_019" },
+    { 0x14, "unk_020" },
+    { 0x15, "unk_021" },
+    { 0x16, "unk_022" },
+    { 0x17, "unk_023" },
+    { 0x18, "unk_024" },
+    { 0x19, "unk_025" },
+    { 0x1A, "unk_026" },
+    { 0x1B, "unk_027" },
+    { 0x1C, "unk_028" },
+    { 0x1D, "unk_029" },
+    { 0x1E, "unk_030" },
+    { 0x1F, "unk_031" },
+    { 0x20, "unk_032" },
+    { 0x21, "unk_033" },
+    { 0x22, "unk_034" },
+    { 0x23, "unk_035" },
+    { 0x24, "unk_036" },
+    { 0x25, "unk_037" },
+    { 0x26, "unk_038" },
+    { 0x27, "unk_039" },
+    { 0x28, "unk_040" },
+    { 0x29, "unk_041" },
+    { 0x2A, "unk_042" },
+    { 0x2B, "unk_043" },
+    { 0x2C, "unk_044" },
+    { 0x2D, "unk_045" },
+    { 0x2E, "unk_046" },
+    { 0x2F, "unk_047" },
+    { 0x30, "unk_048" },
+    { 0x31, "unk_049" },
+    { 0x32, "unk_050" },
+    { 0x33, "unk_051" },
+    { 0x34, "unk_052" },
+    { 0x35, "unk_053" },
+    { 0x36, "unk_054" },
+    { 0x37, "unk_055" },
+    { 0x38, "unk_056" },
+    { 0x39, "unk_057" },
+    { 0x3A, "unk_058" },
+    { 0x3B, "unk_059" },
+    { 0x3C, "unk_060" },
+    { 0x3D, "unk_061" },
+    { 0x3E, "unk_062" },
+    { 0x3F, "unk_063" },
+    { 0x40, "unk_064" },
+    { 0x41, "unk_065" },
+    { 0x42, "unk_066" },
+    { 0x43, "unk_067" },
+    { 0x44, "unk_068" },
+    { 0x45, "unk_069" },
+    { 0x46, "unk_070" },
+    { 0x47, "unk_071" },
+    { 0x48, "unk_072" },
+    { 0x49, "unk_073" },
+    { 0x4A, "unk_074" },
+    { 0x4B, "unk_075" },
+    { 0x4C, "unk_076" },
+    { 0x4D, "unk_077" },
+    { 0x4E, "unk_078" },
+    { 0x4F, "unk_079" },
+    { 0x50, "unk_080" },
+    { 0x51, "unk_081" },
+    { 0x52, "unk_082" },
+    { 0x53, "unk_083" },
+    { 0x54, "unk_084" },
+    { 0x55, "unk_085" },
+    { 0x56, "unk_086" },
+    { 0x57, "unk_087" },
+    { 0x58, "unk_088" },
+    { 0x59, "unk_089" },
+    { 0x5A, "unk_090" },
+    { 0x5B, "unk_091" },
+    { 0x5C, "unk_092" },
+    { 0x5D, "unk_093" },
+    { 0x5E, "unk_094" },
+    { 0x5F, "unk_095" },
+    { 0x60, "unk_096" },
+    { 0x61, "unk_097" },
+    { 0x62, "unk_098" },
+    { 0x63, "unk_099" },
+    { 0x64, "unk_100" },
+    { 0x65, "unk_101" },
+    { 0x66, "unk_102" },
+    { 0x67, "unk_103" },
+    { 0x68, "unk_104" },
+    { 0x69, "unk_105" },
+    { 0x6A, "unk_106" },
+    { 0x6B, "unk_107" },
+    { 0x6C, "unk_108" },
+    { 0x6D, "unk_109" },
+    { 0x6E, "unk_110" },
+    { 0x6F, "unk_111" },
+    { 0x70, "unk_112" },
+    { 0x71, "unk_113" },
+    { 0x72, "unk_114" },
+    { 0x73, "unk_115" },
+    { 0x74, "unk_116" },
+    { 0x75, "unk_117" },
+    { 0x76, "unk_118" },
+    { 0x77, "unk_119" },
+    { 0x78, "unk_120" },
+    { 0x79, "unk_121" },
+    { 0x7A, "unk_122" },
+    { 0x7B, "unk_123" },
+    { 0x7C, "unk_124" },
+    { 0x7D, "unk_125" },
+    { 0x7E, "unk_126" },
+    { 0x7F, "unk_127" },
+    { 0x80, "unk_128" },
+    { 0x81, "unk_129" },
+    { 0x82, "unk_130" },
+    { 0x83, "unk_131" },
+    { 0x84, "unk_132" },
+    { 0x85, "unk_133" },
+    { 0x86, "unk_134" },
+    { 0x87, "unk_135" },
+    { 0x88, "unk_136" },
+    { 0x89, "unk_137" },
+    { 0x8A, "unk_138" },
+    { 0x8B, "unk_139" },
+    { 0x8C, "unk_140" },
+    { 0x8D, "unk_141" },
+    { 0x8E, "unk_142" },
+    { 0x8F, "unk_143" },
+    { 0x90, "unk_144" },
+    { 0x91, "unk_145" },
+    { 0x92, "unk_146" },
+    { 0x93, "unk_147" },
+    { 0x94, "unk_148" },
+    { 0x95, "unk_149" },
+    { 0x96, "unk_150" },
+    { 0x97, "unk_151" },
+    { 0x98, "unk_152" },
+    { 0x99, "unk_153" },
+    { 0x9A, "unk_154" },
+    { 0x9B, "unk_155" },
+    { 0x9C, "unk_156" },
+    { 0x9D, "unk_157" },
+    { 0x9E, "unk_158" },
+    { 0x9F, "unk_159" },
+    { 0xA0, "unk_160" },
+    { 0xA1, "unk_161" },
+    { 0xA2, "unk_162" },
+    { 0xA3, "unk_163" },
+    { 0xA4, "unk_164" },
+    { 0xA5, "unk_165" },
+    { 0xA6, "unk_166" },
+}};
+
+const std::array<std::pair<std::uint16_t, const char*>, 0> function_list
+{{
+}};
+
+const std::array<std::pair<std::uint16_t, const char*>, 0> method_list
+{{
+}};
+
+const std::array<std::pair<std::uint32_t, const char*>, 0> token_list
+{{
+}};
+
+struct __init__
+{
+    __init__()
+    {
+        static bool init = false;
+        if (init) return;
+        init = true;
+
+        opcode_map.reserve(opcode_list.size());
+        opcode_map_rev.reserve(opcode_list.size());
+        function_map.reserve(function_list.size());
+        function_map_rev.reserve(function_list.size());
+        method_map.reserve(method_list.size());
+        method_map_rev.reserve(method_list.size());
+        token_map.reserve(token_list.size());
+        token_map_rev.reserve(token_list.size());
+
+        for (const auto& entry : opcode_list)
+        {
+            opcode_map.insert({ entry.first, entry.second });
+            opcode_map_rev.insert({ entry.second, entry.first });
+        }
+
+        for (const auto& entry : function_list)
+        {
+            function_map.insert({ entry.first, entry.second });
+            function_map_rev.insert({ entry.second, entry.first });
+        }
+
+        for (const auto& entry : method_list)
+        {
+            method_map.insert({ entry.first, entry.second });
+            method_map_rev.insert({ entry.second, entry.first });
+        }
+
+        for (const auto& entry : token_list)
+        {
+            token_map.insert({ entry.first, entry.second });
+            token_map_rev.insert({ entry.second, entry.first });
+        }
+    }
+};
+
+__init__ _;
+
+} // namespace xsk::gsc::iw8
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
diff --git a/src/iw9/xsk/resolver.hpp b/src/iw9/xsk/resolver.hpp
new file mode 100644
index 00000000..b6bbd853
--- /dev/null
+++ b/src/iw9/xsk/resolver.hpp
@@ -0,0 +1,40 @@
+// Copyright 2022 xensik. All rights reserved.
+//
+// Use of this source code is governed by a GNU GPLv3 license
+// that can be found in the LICENSE file.
+
+#pragma once
+
+namespace xsk::gsc::iw9
+{
+
+class resolver
+{
+public:
+    static void init(read_cb_type callback);
+    static void cleanup();
+
+    static auto opcode_id(const std::string& name) -> std::uint8_t;
+    static auto opcode_name(std::uint8_t id) -> std::string;
+
+    static auto function_id(const std::string& name) -> std::uint16_t;
+    static auto function_name(std::uint16_t id) -> std::string;
+
+    static auto method_id(const std::string& name) -> std::uint16_t;
+    static auto method_name(std::uint16_t id) -> std::string;
+
+    static auto token_id(const std::string& name) -> std::uint32_t;
+    static auto token_name(std::uint32_t id) -> std::string;
+
+    static auto find_function(const std::string& name) -> bool;
+    static auto find_method(const std::string& name) -> bool;
+
+    static void add_function(const std::string& name, std::uint16_t id);
+    static void add_method(const std::string& name, std::uint16_t id);
+
+    static auto make_token(std::string_view str) -> std::string;
+    static auto file_data(const std::string& name) -> std::tuple<const std::string*, const char*, size_t>;
+    static auto fs_to_game_path(const std::filesystem::path& file) -> std::filesystem::path;
+};
+
+} // namespace xsk::gsc::iw9
diff --git a/src/tool/xsk/main.cpp b/src/tool/xsk/main.cpp
index 91ff2128..deea8a11 100644
--- a/src/tool/xsk/main.cpp
+++ b/src/tool/xsk/main.cpp
@@ -12,6 +12,7 @@
 #include "iw6/xsk/iw6.hpp"
 #include "iw7/xsk/iw7.hpp"
 #include "iw8/xsk/iw8.hpp"
+#include "iw9/xsk/iw9.hpp"
 #include "s1/xsk/s1.hpp"
 #include "s2/xsk/s2.hpp"
 #include "s4/xsk/s4.hpp"
@@ -24,7 +25,7 @@ namespace xsk
 
 enum class encd { _, source, assembly, binary };
 enum class mode { _, assemble, disassemble, compile, decompile };
-enum class game { _, iw5c, iw6c, s1c, iw5, iw6, iw7, iw8, s1, s2, s4, h1, h2, t6 };
+enum class game { _, iw5c, iw6c, s1c, iw5, iw6, iw7, iw8, iw9, s1, s2, s4, h1, h2, t6 };
 
 const std::map<std::string, encd> exts =
 {
@@ -51,6 +52,7 @@ const std::map<std::string, game> games =
     { "iw6", game::iw6 },
     { "iw7", game::iw7 },
     { "iw8", game::iw8 },
+    { "iw9", game::iw9 },
     { "s1", game::s1 },
     { "s2", game::s2 },
     { "s4", game::s4 },
@@ -118,6 +120,8 @@ auto choose_resolver_file_name(uint32_t id, game& game) -> std::string
             return iw7::resolver::token_name(id);
         case game::iw8:
             return iw8::resolver::token_name(id);
+        case game::iw9:
+            return iw9::resolver::token_name(id);
         case game::s1:
             return s1::resolver::token_name(static_cast<std::uint16_t>(id));
         case game::s2:
@@ -426,6 +430,8 @@ void init()
     contexts[game::iw7]->init(build::prod, utils::file::read);
     contexts[game::iw8] = std::make_unique<iw8::context>();
     contexts[game::iw8]->init(build::prod, utils::file::read);
+    contexts[game::iw9] = std::make_unique<iw9::context>();
+    contexts[game::iw9]->init(build::prod, utils::file::read);
     contexts[game::s1] = std::make_unique<s1::context>();
     contexts[game::s1]->init(build::prod, utils::file::read);
     contexts[game::s2] = std::make_unique<s2::context>();