test.kt:
#    0| [CompilationUnit] test
#    0|   1: [Class] TestKt
#    1|     1: [Method] test
#    1|       3: [TypeAccess] int
#-----|       4: (Parameters)
#    1|         0: [Parameter] m
#    1|           0: [TypeAccess] Map<Integer,Integer>
#    1|             0: [TypeAccess] Integer
#    1|             1: [TypeAccess] Integer
#    1|       5: [BlockStmt] { ... }
#    1|         0: [ReturnStmt] return ...
#    1|           0: [MethodCall] getOrDefault(...)
#    1|             -1: [VarAccess] m
#    1|             0: [IntegerLiteral] 1
#    1|             1: [IntegerLiteral] 2
#    3|     2: [Method] test2
#    3|       3: [TypeAccess] int
#-----|       4: (Parameters)
#    3|         0: [Parameter] s
#    3|           0: [TypeAccess] String
#    3|       5: [BlockStmt] { ... }
#    3|         0: [ReturnStmt] return ...
#    3|           0: [MethodCall] length(...)
#    3|             -1: [VarAccess] s
#    5|     3: [Method] remove
#    5|       3: [TypeAccess] Unit
#-----|       4: (Parameters)
#    5|         0: [Parameter] l
#    5|           0: [TypeAccess] List<Integer>
#    5|             0: [TypeAccess] Integer
#    5|       5: [BlockStmt] { ... }
#    6|         0: [ExprStmt] <Expr>;
#    6|           0: [ImplicitCoercionToUnitExpr] <implicit coercion to unit>
#    6|             0: [TypeAccess] Unit
#    6|             1: [MethodCall] remove(...)
#    6|               -1: [VarAccess] l
#    6|               0: [IntegerLiteral] 5
#    9|     4: [Method] fn1
#    9|       3: [TypeAccess] String
#-----|       4: (Parameters)
#    9|         0: [Parameter] s
#    9|           0: [TypeAccess] String
#    9|       5: [BlockStmt] { ... }
#    9|         0: [ReturnStmt] return ...
#    9|           0: [AddExpr] ... + ...
#    9|             0: [VarAccess] s
#    9|             1: [StringLiteral] ""
#   10|     5: [Method] fn2
#   10|       3: [TypeAccess] String
#-----|       4: (Parameters)
#   10|         0: [Parameter] s
#   10|           0: [TypeAccess] String
#   10|       5: [BlockStmt] { ... }
#   10|         0: [ReturnStmt] return ...
#   10|           0: [AddExpr] ... + ...
#   10|             0: [VarAccess] s
#   10|             1: [StringLiteral] ""
#   12|     6: [Method] fn1
#   12|       3: [TypeAccess] int
#-----|       4: (Parameters)
#   12|         0: [Parameter] i
#   12|           0: [TypeAccess] int
#   12|       5: [BlockStmt] { ... }
#   12|         0: [ReturnStmt] return ...
#   12|           0: [SubExpr] ... - ...
#   12|             0: [VarAccess] i
#   12|             1: [IntegerLiteral] 10
#   13|     7: [Method] fn2
#   13|       3: [TypeAccess] int
#-----|       4: (Parameters)
#   13|         0: [Parameter] i
#   13|           0: [TypeAccess] int
#   13|       5: [BlockStmt] { ... }
#   13|         0: [ReturnStmt] return ...
#   13|           0: [SubExpr] ... - ...
#   13|             0: [VarAccess] i
#   13|             1: [IntegerLiteral] 10
#   15|     8: [Method] special
#   15|       3: [TypeAccess] Unit
#-----|       4: (Parameters)
#   15|         0: [Parameter] n
#   15|           0: [TypeAccess] Number
#   15|         1: [Parameter] m
#   15|           0: [TypeAccess] Map<String,String>
#   15|             0: [TypeAccess] String
#   15|             1: [TypeAccess] String
#   15|         2: [Parameter] s
#   15|           0: [TypeAccess] String
#   15|         3: [Parameter] l
#   15|           0: [TypeAccess] List<Integer>
#   15|             0: [TypeAccess] Integer
#   15|       5: [BlockStmt] { ... }
#   16|         0: [ExprStmt] <Expr>;
#   16|           0: [ImplicitCoercionToUnitExpr] <implicit coercion to unit>
#   16|             0: [TypeAccess] Unit
#   16|             1: [MethodCall] charAt(...)
#   16|               -1: [VarAccess] s
#   16|               0: [IntegerLiteral] 1
#   17|         1: [ExprStmt] <Expr>;
#   17|           0: [ImplicitCoercionToUnitExpr] <implicit coercion to unit>
#   17|             0: [TypeAccess] Unit
#   17|             1: [MethodCall] charAt(...)
#   17|               -1: [VarAccess] s
#   17|               0: [IntegerLiteral] 1
#   18|         2: [ExprStmt] <Expr>;
#   18|           0: [ImplicitCoercionToUnitExpr] <implicit coercion to unit>
#   18|             0: [TypeAccess] Unit
#   18|             1: [MethodCall] doubleValue(...)
#   18|               -1: [VarAccess] n
#   19|         3: [ExprStmt] <Expr>;
#   19|           0: [ImplicitCoercionToUnitExpr] <implicit coercion to unit>
#   19|             0: [TypeAccess] Unit
#   19|             1: [MethodCall] byteValue(...)
#   19|               -1: [VarAccess] n
#   20|         4: [ExprStmt] <Expr>;
#   20|           0: [ImplicitCoercionToUnitExpr] <implicit coercion to unit>
#   20|             0: [TypeAccess] Unit
#   20|             1: [MethodCall] toChar(...)
#   20|               -1: [VarAccess] n
#   21|         5: [ExprStmt] <Expr>;
#   21|           0: [ImplicitCoercionToUnitExpr] <implicit coercion to unit>
#   21|             0: [TypeAccess] Unit
#   21|             1: [MethodCall] floatValue(...)
#   21|               -1: [VarAccess] n
#   22|         6: [ExprStmt] <Expr>;
#   22|           0: [ImplicitCoercionToUnitExpr] <implicit coercion to unit>
#   22|             0: [TypeAccess] Unit
#   22|             1: [MethodCall] intValue(...)
#   22|               -1: [VarAccess] n
#   23|         7: [ExprStmt] <Expr>;
#   23|           0: [ImplicitCoercionToUnitExpr] <implicit coercion to unit>
#   23|             0: [TypeAccess] Unit
#   23|             1: [MethodCall] shortValue(...)
#   23|               -1: [VarAccess] n
#   24|         8: [ExprStmt] <Expr>;
#   24|           0: [ImplicitCoercionToUnitExpr] <implicit coercion to unit>
#   24|             0: [TypeAccess] Unit
#   24|             1: [MethodCall] keySet(...)
#   24|               -1: [VarAccess] m
#   25|         9: [ExprStmt] <Expr>;
#   25|           0: [ImplicitCoercionToUnitExpr] <implicit coercion to unit>
#   25|             0: [TypeAccess] Unit
#   25|             1: [MethodCall] values(...)
#   25|               -1: [VarAccess] m
#   26|         10: [ExprStmt] <Expr>;
#   26|           0: [ImplicitCoercionToUnitExpr] <implicit coercion to unit>
#   26|             0: [TypeAccess] Unit
#   26|             1: [MethodCall] entrySet(...)
#   26|               -1: [VarAccess] m
#   27|         11: [ExprStmt] <Expr>;
#   27|           0: [ImplicitCoercionToUnitExpr] <implicit coercion to unit>
#   27|             0: [TypeAccess] Unit
#   27|             1: [MethodCall] remove(...)
#   27|               -1: [VarAccess] l
#   27|               0: [IntegerLiteral] 1
#   28|         12: [ExprStmt] <Expr>;
#   28|           0: [ImplicitCoercionToUnitExpr] <implicit coercion to unit>
#   28|             0: [TypeAccess] Unit
#   28|             1: [MethodCall] getKey(...)
#   28|               -1: [MethodCall] first(...)
#   28|                 -2: [TypeAccess] Entry<String,String>
#   28|                   0: [TypeAccess] String
#   28|                   1: [TypeAccess] String
#   28|                 -1: [TypeAccess] CollectionsKt
#   28|                 0: [MethodCall] entrySet(...)
#   28|                   -1: [VarAccess] m
#   29|         13: [ExprStmt] <Expr>;
#   29|           0: [ImplicitCoercionToUnitExpr] <implicit coercion to unit>
#   29|             0: [TypeAccess] Unit
#   29|             1: [MethodCall] getValue(...)
#   29|               -1: [MethodCall] first(...)
#   29|                 -2: [TypeAccess] Entry<String,String>
#   29|                   0: [TypeAccess] String
#   29|                   1: [TypeAccess] String
#   29|                 -1: [TypeAccess] CollectionsKt
#   29|                 0: [MethodCall] entrySet(...)
#   29|                   -1: [VarAccess] m