import unittest
from TestUtils import TestAST
from AST import *

class ASTGenSuite(unittest.TestCase):
def test_0(self):
line = '''Class W:_{Val $_,$5,Y_6,__33,s98_X:Array [Array [Int ,0XC_39],35_3];}Class DwV_:WM{}Class O:F{Destructor (){Continue ;}Constructor (Q_,_u:Array [Array [Array [String ,0B11_1],0B1],5]){} }'''
expect = '''Program([ClassDecl(Id(W),Id(_),[AttributeDecl(Static,ConstDecl(Id($_),ArrayType(353,ArrayType(3129,IntType)),None)),AttributeDecl(Static,ConstDecl(Id($5),ArrayType(353,ArrayType(3129,IntType)),None)),AttributeDecl(Instance,ConstDecl(Id(Y_6),ArrayType(353,ArrayType(3129,IntType)),None)),AttributeDecl(Instance,ConstDecl(Id(__33),ArrayType(353,ArrayType(3129,IntType)),None)),AttributeDecl(Instance,ConstDecl(Id(s98_X),ArrayType(353,ArrayType(3129,IntType)),None))]),ClassDecl(Id(DwV_),Id(WM),[]),ClassDecl(Id(O),Id(F),[MethodDecl(Id(Destructor),Instance,[],Block([Continue])),MethodDecl(Id(Constructor),Instance,[param(Id(Q_),ArrayType(5,ArrayType(1,ArrayType(7,StringType)))),param(Id(_u),ArrayType(5,ArrayType(1,ArrayType(7,StringType))))],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 0))

def test_1(self):
line = '''Class h_Q{}Class R2:w{Val H6,$l,_,I__80,$__4w,$896_,$_,_W,$0:_x;Constructor (){}Constructor (r:ps;_X,FJ_,U_4,t:Array [Int ,0x4];_2:Array [Array [Float ,0b1_0],0B1];_O,__0:Array [Array [Array [Array [Boolean ,07],0b1011000],0X2],011];O9c:Array [Array [Boolean ,1],0x57];_I:Boolean ){} }Class _3__j9{}'''
expect = '''Program([ClassDecl(Id(h_Q),[]),ClassDecl(Id(R2),Id(w),[AttributeDecl(Instance,ConstDecl(Id(H6),ClassType(Id(_x)),NullLiteral())),AttributeDecl(Static,ConstDecl(Id($l),ClassType(Id(_x)),NullLiteral())),AttributeDecl(Instance,ConstDecl(Id(_),ClassType(Id(_x)),NullLiteral())),AttributeDecl(Instance,ConstDecl(Id(I__80),ClassType(Id(_x)),NullLiteral())),AttributeDecl(Static,ConstDecl(Id($__4w),ClassType(Id(_x)),NullLiteral())),AttributeDecl(Static,ConstDecl(Id($896_),ClassType(Id(_x)),NullLiteral())),AttributeDecl(Static,ConstDecl(Id($_),ClassType(Id(_x)),NullLiteral())),AttributeDecl(Instance,ConstDecl(Id(_W),ClassType(Id(_x)),NullLiteral())),AttributeDecl(Static,ConstDecl(Id($0),ClassType(Id(_x)),NullLiteral())),MethodDecl(Id(Constructor),Instance,[],Block([])),MethodDecl(Id(Constructor),Instance,[param(Id(r),ClassType(Id(ps))),param(Id(_X),ArrayType(4,IntType)),param(Id(FJ_),ArrayType(4,IntType)),param(Id(U_4),ArrayType(4,IntType)),param(Id(t),ArrayType(4,IntType)),param(Id(_2),ArrayType(1,ArrayType(2,FloatType))),param(Id(_O),ArrayType(9,ArrayType(2,ArrayType(88,ArrayType(7,BoolType))))),param(Id(__0),ArrayType(9,ArrayType(2,ArrayType(88,ArrayType(7,BoolType))))),param(Id(O9c),ArrayType(87,ArrayType(1,BoolType))),param(Id(_I),BoolType)],Block([]))]),ClassDecl(Id(_3__j9),[])])'''
self.assertTrue(TestAST.test(line, expect, 1))

def test_2(self):
line = '''Class _{}Class Y__3{}Class __:h{Val _R:Array [Array [Array [Array [Int ,32],32],0B1_00],32];}Class _U_{$0(T:String ;v,_39,BlX,_:Array [Boolean ,010];c,M_S,_7k,__45:Int ;w,e,r,b,_N:_){} }'''
expect = '''Program([ClassDecl(Id(_),[]),ClassDecl(Id(Y__3),[]),ClassDecl(Id(__),Id(h),[AttributeDecl(Instance,ConstDecl(Id(_R),ArrayType(32,ArrayType(4,ArrayType(32,ArrayType(32,IntType)))),None))]),ClassDecl(Id(_U_),[MethodDecl(Id($0),Static,[param(Id(T),StringType),param(Id(v),ArrayType(8,BoolType)),param(Id(_39),ArrayType(8,BoolType)),param(Id(BlX),ArrayType(8,BoolType)),param(Id(_),ArrayType(8,BoolType)),param(Id(c),IntType),param(Id(M_S),IntType),param(Id(_7k),IntType),param(Id(__45),IntType),param(Id(w),ClassType(Id(_))),param(Id(e),ClassType(Id(_))),param(Id(r),ClassType(Id(_))),param(Id(b),ClassType(Id(_))),param(Id(_N),ClassType(Id(_)))],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 2))

def test_3(self):
line = '''Class h:_8{Constructor (A,HR,K,e_:Array [Array [Array [Float ,6],0B101101],3];_,U:_;uV:_8;_,rY,w:Array [Array [Array [Float ,31],0B101101],0X50];DP0_:String ){}Destructor (){}Val $_,$x9j:__;Destructor (){}Val $1,___:_0;Destructor (){} }Class b:_{Constructor (D_9C,_,G:__An;n:Array [Int ,045];_,_,I3:__;_,N8Ff,_:__489){Break ;} }'''
expect = '''Program([ClassDecl(Id(h),Id(_8),[MethodDecl(Id(Constructor),Instance,[param(Id(A),ArrayType(3,ArrayType(45,ArrayType(6,FloatType)))),param(Id(HR),ArrayType(3,ArrayType(45,ArrayType(6,FloatType)))),param(Id(K),ArrayType(3,ArrayType(45,ArrayType(6,FloatType)))),param(Id(e_),ArrayType(3,ArrayType(45,ArrayType(6,FloatType)))),param(Id(_),ClassType(Id(_))),param(Id(U),ClassType(Id(_))),param(Id(uV),ClassType(Id(_8))),param(Id(_),ArrayType(80,ArrayType(45,ArrayType(31,FloatType)))),param(Id(rY),ArrayType(80,ArrayType(45,ArrayType(31,FloatType)))),param(Id(w),ArrayType(80,ArrayType(45,ArrayType(31,FloatType)))),param(Id(DP0_),StringType)],Block([])),MethodDecl(Id(Destructor),Instance,[],Block([])),AttributeDecl(Static,ConstDecl(Id($_),ClassType(Id(__)),NullLiteral())),AttributeDecl(Static,ConstDecl(Id($x9j),ClassType(Id(__)),NullLiteral())),MethodDecl(Id(Destructor),Instance,[],Block([])),AttributeDecl(Static,ConstDecl(Id($1),ClassType(Id(_0)),NullLiteral())),AttributeDecl(Instance,ConstDecl(Id(___),ClassType(Id(_0)),NullLiteral())),MethodDecl(Id(Destructor),Instance,[],Block([]))]),ClassDecl(Id(b),Id(_),[MethodDecl(Id(Constructor),Instance,[param(Id(D_9C),ClassType(Id(__An))),param(Id(_),ClassType(Id(__An))),param(Id(G),ClassType(Id(__An))),param(Id(n),ArrayType(37,IntType)),param(Id(_),ClassType(Id(__))),param(Id(_),ClassType(Id(__))),param(Id(I3),ClassType(Id(__))),param(Id(_),ClassType(Id(__489))),param(Id(N8Ff),ClassType(Id(__489))),param(Id(_),ClassType(Id(__489)))],Block([Break]))])])'''
self.assertTrue(TestAST.test(line, expect, 3))

def test_4(self):
line = '''Class G{}Class xA:Ib1{Var $200__U:Array [Array [Array [Array [Int ,01_6_0],28],0xA_5D],0100];Destructor (){}Val $A,_,$_p_:Array [Array [Array [Array [Array [Int ,06],0100],0100],47],0100];}'''
expect = '''Program([ClassDecl(Id(G),[]),ClassDecl(Id(xA),Id(Ib1),[AttributeDecl(Static,VarDecl(Id($200__U),ArrayType(64,ArrayType(2653,ArrayType(28,ArrayType(112,IntType)))))),MethodDecl(Id(Destructor),Instance,[],Block([])),AttributeDecl(Static,ConstDecl(Id($A),ArrayType(64,ArrayType(47,ArrayType(64,ArrayType(64,ArrayType(6,IntType))))),None)),AttributeDecl(Instance,ConstDecl(Id(_),ArrayType(64,ArrayType(47,ArrayType(64,ArrayType(64,ArrayType(6,IntType))))),None)),AttributeDecl(Static,ConstDecl(Id($_p_),ArrayType(64,ArrayType(47,ArrayType(64,ArrayType(64,ArrayType(6,IntType))))),None))])])'''
self.assertTrue(TestAST.test(line, expect, 4))

def test_5(self):
line = '''Class ebSg7:__{Destructor (){}$d(D_,J,_:Array [Boolean ,0xF];_A_ak0,b:fo;_Y_Row_:Array [Float ,022]){Return ;}$_(){Return ;}Var $_,$_,$_R,_,$C:Array [Boolean ,01_1];Var $7_V:Array [Boolean ,0XB_1];Destructor (){} }'''
expect = '''Program([ClassDecl(Id(ebSg7),Id(__),[MethodDecl(Id(Destructor),Instance,[],Block([])),MethodDecl(Id($d),Static,[param(Id(D_),ArrayType(15,BoolType)),param(Id(J),ArrayType(15,BoolType)),param(Id(_),ArrayType(15,BoolType)),param(Id(_A_ak0),ClassType(Id(fo))),param(Id(b),ClassType(Id(fo))),param(Id(_Y_Row_),ArrayType(18,FloatType))],Block([Return()])),MethodDecl(Id($_),Static,[],Block([Return()])),AttributeDecl(Static,VarDecl(Id($_),ArrayType(9,BoolType))),AttributeDecl(Static,VarDecl(Id($_),ArrayType(9,BoolType))),AttributeDecl(Static,VarDecl(Id($_R),ArrayType(9,BoolType))),AttributeDecl(Instance,VarDecl(Id(_),ArrayType(9,BoolType))),AttributeDecl(Static,VarDecl(Id($C),ArrayType(9,BoolType))),AttributeDecl(Static,VarDecl(Id($7_V),ArrayType(177,BoolType))),MethodDecl(Id(Destructor),Instance,[],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 5))

def test_6(self):
line = '''Class k:_{Oe(d:Array [Int ,0b1_01_1001];__0,f_,_M:Array [Array [Int ,74],0B111011];__t3:u___5;H:Array [Array [Array [Array [Array [Boolean ,04],0B1],0b1011011],74],0X64];Pp,h:_;B_:Array [Int ,0B111011]){} }'''
expect = '''Program([ClassDecl(Id(k),Id(_),[MethodDecl(Id(Oe),Instance,[param(Id(d),ArrayType(89,IntType)),param(Id(__0),ArrayType(59,ArrayType(74,IntType))),param(Id(f_),ArrayType(59,ArrayType(74,IntType))),param(Id(_M),ArrayType(59,ArrayType(74,IntType))),param(Id(__t3),ClassType(Id(u___5))),param(Id(H),ArrayType(100,ArrayType(74,ArrayType(91,ArrayType(1,ArrayType(4,BoolType)))))),param(Id(Pp),ClassType(Id(_))),param(Id(h),ClassType(Id(_))),param(Id(B_),ArrayType(59,IntType))],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 6))

def test_7(self):
line = '''Class w{Constructor (_:Array [Array [Array [Boolean ,0XE2],4204],0b111];K,d_,_,z3v_Z,l:_;IUh2e2s,_7__e,P:String ;M,uO,G7FBs:Boolean ;_0:L_;_5:d;_:Q_P){Var EL9:__;} }'''
expect = '''Program([ClassDecl(Id(w),[MethodDecl(Id(Constructor),Instance,[param(Id(_),ArrayType(7,ArrayType(4204,ArrayType(226,BoolType)))),param(Id(K),ClassType(Id(_))),param(Id(d_),ClassType(Id(_))),param(Id(_),ClassType(Id(_))),param(Id(z3v_Z),ClassType(Id(_))),param(Id(l),ClassType(Id(_))),param(Id(IUh2e2s),StringType),param(Id(_7__e),StringType),param(Id(P),StringType),param(Id(M),BoolType),param(Id(uO),BoolType),param(Id(G7FBs),BoolType),param(Id(_0),ClassType(Id(L_))),param(Id(_5),ClassType(Id(d))),param(Id(_),ClassType(Id(Q_P)))],Block([VarDecl(Id(EL9),ClassType(Id(__)),NullLiteral())]))])])'''
self.assertTrue(TestAST.test(line, expect, 7))

def test_8(self):
line = '''Class N{Constructor (AMjlC_kDk_,P:Array [Int ,012];q,_,y,j_X:Int ){}Constructor (_:_;_82:Array [Array [Boolean ,05],0x3C];q:Array [String ,2_3_83];G:Array [String ,07];_:__){} }Class _0p:_{}'''
expect = '''Program([ClassDecl(Id(N),[MethodDecl(Id(Constructor),Instance,[param(Id(AMjlC_kDk_),ArrayType(10,IntType)),param(Id(P),ArrayType(10,IntType)),param(Id(q),IntType),param(Id(_),IntType),param(Id(y),IntType),param(Id(j_X),IntType)],Block([])),MethodDecl(Id(Constructor),Instance,[param(Id(_),ClassType(Id(_))),param(Id(_82),ArrayType(60,ArrayType(5,BoolType))),param(Id(q),ArrayType(2383,StringType)),param(Id(G),ArrayType(7,StringType)),param(Id(_),ClassType(Id(__)))],Block([]))]),ClassDecl(Id(_0p),Id(_),[])])'''
self.assertTrue(TestAST.test(line, expect, 8))

def test_9(self):
line = '''Class _{}Class _:P{_(__,_1:Float ){}Val $3_:Array [Array [Array [Boolean ,0x56],041],3_4215];Val $e_7_5:__7;Var __,_R,l:Array [String ,041];v(_E,V,Cu,_:Array [String ,0B1];J,__5_k_,_p,_,_,v:Array [String ,0xF_C_5_B]){}Val ___3,_:Array [Array [Array [Boolean ,0b11_0],99],99];Var $_:Boolean ;}'''
expect = '''Program([ClassDecl(Id(_),[]),ClassDecl(Id(_),Id(P),[MethodDecl(Id(_),Instance,[param(Id(__),FloatType),param(Id(_1),FloatType)],Block([])),AttributeDecl(Static,ConstDecl(Id($3_),ArrayType(34215,ArrayType(33,ArrayType(86,BoolType))),None)),AttributeDecl(Static,ConstDecl(Id($e_7_5),ClassType(Id(__7)),NullLiteral())),AttributeDecl(Instance,VarDecl(Id(__),ArrayType(33,StringType))),AttributeDecl(Instance,VarDecl(Id(_R),ArrayType(33,StringType))),AttributeDecl(Instance,VarDecl(Id(l),ArrayType(33,StringType))),MethodDecl(Id(v),Instance,[param(Id(_E),ArrayType(1,StringType)),param(Id(V),ArrayType(1,StringType)),param(Id(Cu),ArrayType(1,StringType)),param(Id(_),ArrayType(1,StringType)),param(Id(J),ArrayType(64603,StringType)),param(Id(__5_k_),ArrayType(64603,StringType)),param(Id(_p),ArrayType(64603,StringType)),param(Id(_),ArrayType(64603,StringType)),param(Id(_),ArrayType(64603,StringType)),param(Id(v),ArrayType(64603,StringType))],Block([])),AttributeDecl(Instance,ConstDecl(Id(___3),ArrayType(99,ArrayType(99,ArrayType(6,BoolType))),None)),AttributeDecl(Instance,ConstDecl(Id(_),ArrayType(99,ArrayType(99,ArrayType(6,BoolType))),None)),AttributeDecl(Static,VarDecl(Id($_),BoolType))])])'''
self.assertTrue(TestAST.test(line, expect, 9))

def test_10(self):
line = '''Class __Z7{Var $I:Int ;Val $I:Array [Array [Array [Array [Array [Array [Array [Array [Array [Float ,0x11],013_0],033],6],6],0x11],0X74_4],4],2_27];Destructor (){} }Class _:__{Val _,_9:_5;}Class O{}'''
expect = '''Program([ClassDecl(Id(__Z7),[AttributeDecl(Static,VarDecl(Id($I),IntType)),AttributeDecl(Static,ConstDecl(Id($I),ArrayType(227,ArrayType(4,ArrayType(1860,ArrayType(17,ArrayType(6,ArrayType(6,ArrayType(27,ArrayType(88,ArrayType(17,FloatType))))))))),None)),MethodDecl(Id(Destructor),Instance,[],Block([]))]),ClassDecl(Id(_),Id(__),[AttributeDecl(Instance,ConstDecl(Id(_),ClassType(Id(_5)),NullLiteral())),AttributeDecl(Instance,ConstDecl(Id(_9),ClassType(Id(_5)),NullLiteral()))]),ClassDecl(Id(O),[])])'''
self.assertTrue(TestAST.test(line, expect, 10))

def test_11(self):
line = '''Class __{}Class _:d{}Class t_{Val _1S04_:Float ;Var $1_a6__,I:Array [Array [Array [Float ,72],72],0x22];_(){}_(_6_,_,_d:Array [Array [Boolean ,8],72]){} }Class yu5_:T__{}Class R{}Class v:P{}Class e0{}'''
expect = '''Program([ClassDecl(Id(__),[]),ClassDecl(Id(_),Id(d),[]),ClassDecl(Id(t_),[AttributeDecl(Instance,ConstDecl(Id(_1S04_),FloatType,None)),AttributeDecl(Static,VarDecl(Id($1_a6__),ArrayType(34,ArrayType(72,ArrayType(72,FloatType))))),AttributeDecl(Instance,VarDecl(Id(I),ArrayType(34,ArrayType(72,ArrayType(72,FloatType))))),MethodDecl(Id(_),Instance,[],Block([])),MethodDecl(Id(_),Instance,[param(Id(_6_),ArrayType(72,ArrayType(8,BoolType))),param(Id(_),ArrayType(72,ArrayType(8,BoolType))),param(Id(_d),ArrayType(72,ArrayType(8,BoolType)))],Block([]))]),ClassDecl(Id(yu5_),Id(T__),[]),ClassDecl(Id(R),[]),ClassDecl(Id(v),Id(P),[]),ClassDecl(Id(e0),[])])'''
self.assertTrue(TestAST.test(line, expect, 11))

def test_12(self):
line = '''Class o8:_2{Val _8,__7n_tB,_x,$0C,JRFt,Z,g2,b:e;Constructor (_G:Array [Array [Boolean ,0X2],0x6];a_:Float ;w7K:String ;t,_:_;b_V_:Array [Array [Float ,0B1_0],38]){} }Class _{Val $bB:MO;}'''
expect = '''Program([ClassDecl(Id(o8),Id(_2),[AttributeDecl(Instance,ConstDecl(Id(_8),ClassType(Id(e)),NullLiteral())),AttributeDecl(Instance,ConstDecl(Id(__7n_tB),ClassType(Id(e)),NullLiteral())),AttributeDecl(Instance,ConstDecl(Id(_x),ClassType(Id(e)),NullLiteral())),AttributeDecl(Static,ConstDecl(Id($0C),ClassType(Id(e)),NullLiteral())),AttributeDecl(Instance,ConstDecl(Id(JRFt),ClassType(Id(e)),NullLiteral())),AttributeDecl(Instance,ConstDecl(Id(Z),ClassType(Id(e)),NullLiteral())),AttributeDecl(Instance,ConstDecl(Id(g2),ClassType(Id(e)),NullLiteral())),AttributeDecl(Instance,ConstDecl(Id(b),ClassType(Id(e)),NullLiteral())),MethodDecl(Id(Constructor),Instance,[param(Id(_G),ArrayType(6,ArrayType(2,BoolType))),param(Id(a_),FloatType),param(Id(w7K),StringType),param(Id(t),ClassType(Id(_))),param(Id(_),ClassType(Id(_))),param(Id(b_V_),ArrayType(38,ArrayType(2,FloatType)))],Block([]))]),ClassDecl(Id(_),[AttributeDecl(Static,ConstDecl(Id($bB),ClassType(Id(MO)),NullLiteral()))])])'''
self.assertTrue(TestAST.test(line, expect, 12))

def test_13(self):
line = '''Class e{Val $W,j:_;Val $9Z,_:Array [Array [Array [Boolean ,0xD_A],0B1],035];}Class G{Constructor (_:Array [Boolean ,0B11010];p:Array [Array [Array [Int ,035],0X6],7]){Continue ;} }Class _M:_kv_{Destructor (){}Var $PZ:_;}'''
expect = '''Program([ClassDecl(Id(e),[AttributeDecl(Static,ConstDecl(Id($W),ClassType(Id(_)),NullLiteral())),AttributeDecl(Instance,ConstDecl(Id(j),ClassType(Id(_)),NullLiteral())),AttributeDecl(Static,ConstDecl(Id($9Z),ArrayType(29,ArrayType(1,ArrayType(218,BoolType))),None)),AttributeDecl(Instance,ConstDecl(Id(_),ArrayType(29,ArrayType(1,ArrayType(218,BoolType))),None))]),ClassDecl(Id(G),[MethodDecl(Id(Constructor),Instance,[param(Id(_),ArrayType(26,BoolType)),param(Id(p),ArrayType(7,ArrayType(6,ArrayType(29,IntType))))],Block([Continue]))]),ClassDecl(Id(_M),Id(_kv_),[MethodDecl(Id(Destructor),Instance,[],Block([])),AttributeDecl(Static,VarDecl(Id($PZ),ClassType(Id(_)),NullLiteral()))])])'''
self.assertTrue(TestAST.test(line, expect, 13))

def test_14(self):
line = '''Class V:_{}Class K:_{Constructor (){}Val $C,$6:String ;}Class __{Var $__,$5:Int ;Var _:Int ;}Class _45{}Class _4:K0r7U{Constructor (R,_e:Float ;_,D,_wB87_:Array [Boolean ,0B1_0]){}Destructor (){ {} }}Class f_8{}'''
expect = '''Program([ClassDecl(Id(V),Id(_),[]),ClassDecl(Id(K),Id(_),[MethodDecl(Id(Constructor),Instance,[],Block([])),AttributeDecl(Static,ConstDecl(Id($C),StringType,None)),AttributeDecl(Static,ConstDecl(Id($6),StringType,None))]),ClassDecl(Id(__),[AttributeDecl(Static,VarDecl(Id($__),IntType)),AttributeDecl(Static,VarDecl(Id($5),IntType)),AttributeDecl(Instance,VarDecl(Id(_),IntType))]),ClassDecl(Id(_45),[]),ClassDecl(Id(_4),Id(K0r7U),[MethodDecl(Id(Constructor),Instance,[param(Id(R),FloatType),param(Id(_e),FloatType),param(Id(_),ArrayType(2,BoolType)),param(Id(D),ArrayType(2,BoolType)),param(Id(_wB87_),ArrayType(2,BoolType))],Block([])),MethodDecl(Id(Destructor),Instance,[],Block([Block([])]))]),ClassDecl(Id(f_8),[])])'''
self.assertTrue(TestAST.test(line, expect, 14))

def test_15(self):
line = '''Class c:Q{Var _,$__:Array [Array [Array [Array [Float ,063],0xFF],0X2_2],9_6];Val $D,$____:cX;}Class ___Z:_{}Class G:y{Constructor (i:_4t;_,_,P:Int ;_,o,i:Float ){}Destructor (){} }'''
expect = '''Program([ClassDecl(Id(c),Id(Q),[AttributeDecl(Instance,VarDecl(Id(_),ArrayType(96,ArrayType(34,ArrayType(255,ArrayType(51,FloatType)))))),AttributeDecl(Static,VarDecl(Id($__),ArrayType(96,ArrayType(34,ArrayType(255,ArrayType(51,FloatType)))))),AttributeDecl(Static,ConstDecl(Id($D),ClassType(Id(cX)),NullLiteral())),AttributeDecl(Static,ConstDecl(Id($____),ClassType(Id(cX)),NullLiteral()))]),ClassDecl(Id(___Z),Id(_),[]),ClassDecl(Id(G),Id(y),[MethodDecl(Id(Constructor),Instance,[param(Id(i),ClassType(Id(_4t))),param(Id(_),IntType),param(Id(_),IntType),param(Id(P),IntType),param(Id(_),FloatType),param(Id(o),FloatType),param(Id(i),FloatType)],Block([])),MethodDecl(Id(Destructor),Instance,[],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 15))

def test_16(self):
line = '''Class _:_{$qI(___,_3_X,_1,q,W,G:Int ;_,y___,m_:Int ){}Destructor (){}$H_(f,X,__:J;__,_:s;E:_;_,__,_,_:Int ){Var _2w_1,_KL2N_,__,_6:Array [Array [Array [Array [Array [String ,027],0B1100],7],0b111011],04];Continue ;} }'''
expect = '''Program([ClassDecl(Id(_),Id(_),[MethodDecl(Id($qI),Static,[param(Id(___),IntType),param(Id(_3_X),IntType),param(Id(_1),IntType),param(Id(q),IntType),param(Id(W),IntType),param(Id(G),IntType),param(Id(_),IntType),param(Id(y___),IntType),param(Id(m_),IntType)],Block([])),MethodDecl(Id(Destructor),Instance,[],Block([])),MethodDecl(Id($H_),Static,[param(Id(f),ClassType(Id(J))),param(Id(X),ClassType(Id(J))),param(Id(__),ClassType(Id(J))),param(Id(__),ClassType(Id(s))),param(Id(_),ClassType(Id(s))),param(Id(E),ClassType(Id(_))),param(Id(_),IntType),param(Id(__),IntType),param(Id(_),IntType),param(Id(_),IntType)],Block([VarDecl(Id(_2w_1),ArrayType(4,ArrayType(59,ArrayType(7,ArrayType(12,ArrayType(23,StringType)))))),VarDecl(Id(_KL2N_),ArrayType(4,ArrayType(59,ArrayType(7,ArrayType(12,ArrayType(23,StringType)))))),VarDecl(Id(__),ArrayType(4,ArrayType(59,ArrayType(7,ArrayType(12,ArrayType(23,StringType)))))),VarDecl(Id(_6),ArrayType(4,ArrayType(59,ArrayType(7,ArrayType(12,ArrayType(23,StringType)))))),Continue]))])])'''
self.assertTrue(TestAST.test(line, expect, 16))

def test_17(self):
line = '''Class m1{Constructor (_:LW;o:Array [Float ,3];S:Boolean ){Var D,_P,d,_:Array [Array [Boolean ,026],46];Break ;}Constructor (_3:_X1){} }Class __:n{Var $_,_D:Array [Array [Boolean ,46],05];}'''
expect = '''Program([ClassDecl(Id(m1),[MethodDecl(Id(Constructor),Instance,[param(Id(_),ClassType(Id(LW))),param(Id(o),ArrayType(3,FloatType)),param(Id(S),BoolType)],Block([VarDecl(Id(D),ArrayType(46,ArrayType(22,BoolType))),VarDecl(Id(_P),ArrayType(46,ArrayType(22,BoolType))),VarDecl(Id(d),ArrayType(46,ArrayType(22,BoolType))),VarDecl(Id(_),ArrayType(46,ArrayType(22,BoolType))),Break])),MethodDecl(Id(Constructor),Instance,[param(Id(_3),ClassType(Id(_X1)))],Block([]))]),ClassDecl(Id(__),Id(n),[AttributeDecl(Static,VarDecl(Id($_),ArrayType(5,ArrayType(46,BoolType)))),AttributeDecl(Instance,VarDecl(Id(_D),ArrayType(5,ArrayType(46,BoolType))))])])'''
self.assertTrue(TestAST.test(line, expect, 17))

def test_18(self):
line = '''Class M8Z_D:b_{_8r(){}P_(_C16_:Array [Array [Float ,0X8],04]){}Var $_5:String ;Var $d,_,$_3_:Array [Array [Int ,89],0X8];}Class _{Val t,_:__;Val $_,$A1g_:B_;}Class Y:_{Val I_9_:w;$5(){}$7v(_3_x,_:Int ;Vs_5,h:Array [Array [Int ,3],0b1_10]){}Var NE:Boolean ;}Class _{}Class _:_E{}'''
expect = '''Program([ClassDecl(Id(M8Z_D),Id(b_),[MethodDecl(Id(_8r),Instance,[],Block([])),MethodDecl(Id(P_),Instance,[param(Id(_C16_),ArrayType(4,ArrayType(8,FloatType)))],Block([])),AttributeDecl(Static,VarDecl(Id($_5),StringType)),AttributeDecl(Static,VarDecl(Id($d),ArrayType(8,ArrayType(89,IntType)))),AttributeDecl(Instance,VarDecl(Id(_),ArrayType(8,ArrayType(89,IntType)))),AttributeDecl(Static,VarDecl(Id($_3_),ArrayType(8,ArrayType(89,IntType))))]),ClassDecl(Id(_),[AttributeDecl(Instance,ConstDecl(Id(t),ClassType(Id(__)),NullLiteral())),AttributeDecl(Instance,ConstDecl(Id(_),ClassType(Id(__)),NullLiteral())),AttributeDecl(Static,ConstDecl(Id($_),ClassType(Id(B_)),NullLiteral())),AttributeDecl(Static,ConstDecl(Id($A1g_),ClassType(Id(B_)),NullLiteral()))]),ClassDecl(Id(Y),Id(_),[AttributeDecl(Instance,ConstDecl(Id(I_9_),ClassType(Id(w)),NullLiteral())),MethodDecl(Id($5),Static,[],Block([])),MethodDecl(Id($7v),Static,[param(Id(_3_x),IntType),param(Id(_),IntType),param(Id(Vs_5),ArrayType(6,ArrayType(3,IntType))),param(Id(h),ArrayType(6,ArrayType(3,IntType)))],Block([])),AttributeDecl(Instance,VarDecl(Id(NE),BoolType))]),ClassDecl(Id(_),[]),ClassDecl(Id(_),Id(_E),[])])'''
self.assertTrue(TestAST.test(line, expect, 18))

def test_19(self):
line = '''Class q{}Class l{}Class w:y2__{Constructor (){}Destructor (){ {Return ;Continue ;} }Constructor (){Continue ;} }Class h_{Destructor (){Return ;Break ;Val __:__;___l::$_E._();} }'''
expect = '''Program([ClassDecl(Id(q),[]),ClassDecl(Id(l),[]),ClassDecl(Id(w),Id(y2__),[MethodDecl(Id(Constructor),Instance,[],Block([])),MethodDecl(Id(Destructor),Instance,[],Block([Block([Return(),Continue])])),MethodDecl(Id(Constructor),Instance,[],Block([Continue]))]),ClassDecl(Id(h_),[MethodDecl(Id(Destructor),Instance,[],Block([Return(),Break,ConstDecl(Id(__),ClassType(Id(__)),NullLiteral()),Call(FieldAccess(Id(___l),Id($_E)),Id(_),[])]))])])'''
self.assertTrue(TestAST.test(line, expect, 19))

def test_20(self):
line = '''Class t:e_{Val $__,$d9g:sN;_(_,X,_,_415OF1,__,k,_:Array [Array [Array [Array [Boolean ,0125_0_1_6],01],0105],0B1_0];W0uF49q:String ;_,_:_;_UG__,jn,R:Boolean ;V:Float ){} }Class D0:_16{}Class q_5G_:N_7k{_7(_,x,X_:Float ;m1:_){} }'''
expect = '''Program([ClassDecl(Id(t),Id(e_),[AttributeDecl(Static,ConstDecl(Id($__),ClassType(Id(sN)),NullLiteral())),AttributeDecl(Static,ConstDecl(Id($d9g),ClassType(Id(sN)),NullLiteral())),MethodDecl(Id(_),Instance,[param(Id(_),ArrayType(2,ArrayType(69,ArrayType(1,ArrayType(43534,BoolType))))),param(Id(X),ArrayType(2,ArrayType(69,ArrayType(1,ArrayType(43534,BoolType))))),param(Id(_),ArrayType(2,ArrayType(69,ArrayType(1,ArrayType(43534,BoolType))))),param(Id(_415OF1),ArrayType(2,ArrayType(69,ArrayType(1,ArrayType(43534,BoolType))))),param(Id(__),ArrayType(2,ArrayType(69,ArrayType(1,ArrayType(43534,BoolType))))),param(Id(k),ArrayType(2,ArrayType(69,ArrayType(1,ArrayType(43534,BoolType))))),param(Id(_),ArrayType(2,ArrayType(69,ArrayType(1,ArrayType(43534,BoolType))))),param(Id(W0uF49q),StringType),param(Id(_),ClassType(Id(_))),param(Id(_),ClassType(Id(_))),param(Id(_UG__),BoolType),param(Id(jn),BoolType),param(Id(R),BoolType),param(Id(V),FloatType)],Block([]))]),ClassDecl(Id(D0),Id(_16),[]),ClassDecl(Id(q_5G_),Id(N_7k),[MethodDecl(Id(_7),Instance,[param(Id(_),FloatType),param(Id(x),FloatType),param(Id(X_),FloatType),param(Id(m1),ClassType(Id(_)))],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 20))

def test_21(self):
line = '''Class e{$__X(){Continue ;}$___(_,_,_T:Array [Array [Boolean ,0xB3],0X58];SW,S452:Array [Array [String ,0b1001011],074];_,a:Array [Array [String ,0X8],0b1001011];d0,_:Array [Int ,0B1]){} }Class pZnS_{Destructor (){_::$_().___v();Break ;} }'''
expect = '''Program([ClassDecl(Id(e),[MethodDecl(Id($__X),Static,[],Block([Continue])),MethodDecl(Id($___),Static,[param(Id(_),ArrayType(88,ArrayType(179,BoolType))),param(Id(_),ArrayType(88,ArrayType(179,BoolType))),param(Id(_T),ArrayType(88,ArrayType(179,BoolType))),param(Id(SW),ArrayType(60,ArrayType(75,StringType))),param(Id(S452),ArrayType(60,ArrayType(75,StringType))),param(Id(_),ArrayType(75,ArrayType(8,StringType))),param(Id(a),ArrayType(75,ArrayType(8,StringType))),param(Id(d0),ArrayType(1,IntType)),param(Id(_),ArrayType(1,IntType))],Block([]))]),ClassDecl(Id(pZnS_),[MethodDecl(Id(Destructor),Instance,[],Block([Call(CallExpr(Id(_),Id($_),[]),Id(___v),[]),Break]))])])'''
self.assertTrue(TestAST.test(line, expect, 21))

def test_22(self):
line = '''Class __{Val $u,_qq,i,_B_,$f:Array [Array [Array [String ,0B11],11],6];}Class _{}Class X4:DL{Rj_9(h_6,__,k:Array [Array [Boolean ,0xFE_6],02]){Break ;} }Class _w_t3_{}Class _sV{Constructor (){} }Class _5__4:e{}Class ZE:Jz{Val _:B2;}'''
expect = '''Program([ClassDecl(Id(__),[AttributeDecl(Static,ConstDecl(Id($u),ArrayType(6,ArrayType(11,ArrayType(3,StringType))),None)),AttributeDecl(Instance,ConstDecl(Id(_qq),ArrayType(6,ArrayType(11,ArrayType(3,StringType))),None)),AttributeDecl(Instance,ConstDecl(Id(i),ArrayType(6,ArrayType(11,ArrayType(3,StringType))),None)),AttributeDecl(Instance,ConstDecl(Id(_B_),ArrayType(6,ArrayType(11,ArrayType(3,StringType))),None)),AttributeDecl(Static,ConstDecl(Id($f),ArrayType(6,ArrayType(11,ArrayType(3,StringType))),None))]),ClassDecl(Id(_),[]),ClassDecl(Id(X4),Id(DL),[MethodDecl(Id(Rj_9),Instance,[param(Id(h_6),ArrayType(2,ArrayType(4070,BoolType))),param(Id(__),ArrayType(2,ArrayType(4070,BoolType))),param(Id(k),ArrayType(2,ArrayType(4070,BoolType)))],Block([Break]))]),ClassDecl(Id(_w_t3_),[]),ClassDecl(Id(_sV),[MethodDecl(Id(Constructor),Instance,[],Block([]))]),ClassDecl(Id(_5__4),Id(e),[]),ClassDecl(Id(ZE),Id(Jz),[AttributeDecl(Instance,ConstDecl(Id(_),ClassType(Id(B2)),NullLiteral()))])])'''
self.assertTrue(TestAST.test(line, expect, 22))

def test_23(self):
line = '''Class _:a8_{}Class _:X_2{Constructor (P:Array [Int ,0X6_7];W,_,_Y:Array [Boolean ,0B111100];I_:_p_){}Var $_2:Array [String ,3_8807];Constructor (E:Array [Array [Boolean ,0B111100],0xC]){ {} }}'''
expect = '''Program([ClassDecl(Id(_),Id(a8_),[]),ClassDecl(Id(_),Id(X_2),[MethodDecl(Id(Constructor),Instance,[param(Id(P),ArrayType(103,IntType)),param(Id(W),ArrayType(60,BoolType)),param(Id(_),ArrayType(60,BoolType)),param(Id(_Y),ArrayType(60,BoolType)),param(Id(I_),ClassType(Id(_p_)))],Block([])),AttributeDecl(Static,VarDecl(Id($_2),ArrayType(38807,StringType))),MethodDecl(Id(Constructor),Instance,[param(Id(E),ArrayType(12,ArrayType(60,BoolType)))],Block([Block([])]))])])'''
self.assertTrue(TestAST.test(line, expect, 23))

def test_24(self):
line = '''Class __{X_(E,g:Float ;q5,_IW:Array [Array [Float ,07],0B1010000]){}Val B564,$7Nd,z:Array [Array [Boolean ,0xE_C],0x41];}Class _L_:_8y{}Class ZO{Destructor (){}Constructor (){Break ;} }Class CA{}'''
expect = '''Program([ClassDecl(Id(__),[MethodDecl(Id(X_),Instance,[param(Id(E),FloatType),param(Id(g),FloatType),param(Id(q5),ArrayType(80,ArrayType(7,FloatType))),param(Id(_IW),ArrayType(80,ArrayType(7,FloatType)))],Block([])),AttributeDecl(Instance,ConstDecl(Id(B564),ArrayType(65,ArrayType(236,BoolType)),None)),AttributeDecl(Static,ConstDecl(Id($7Nd),ArrayType(65,ArrayType(236,BoolType)),None)),AttributeDecl(Instance,ConstDecl(Id(z),ArrayType(65,ArrayType(236,BoolType)),None))]),ClassDecl(Id(_L_),Id(_8y),[]),ClassDecl(Id(ZO),[MethodDecl(Id(Destructor),Instance,[],Block([])),MethodDecl(Id(Constructor),Instance,[],Block([Break]))]),ClassDecl(Id(CA),[])])'''
self.assertTrue(TestAST.test(line, expect, 24))

def test_25(self):
line = '''Class _{Destructor (){}Constructor (){} }Class k{}Class _6{Var k3,n,__,$2:_;}Class _:____{Destructor (){}Var d:Array [Array [Float ,07],5_5];Val _d_1v:Array [Array [Float ,0X5E],0B1001000];}Class y__0_:n{f(D5,_:Array [String ,0B1];_,bp,_:_;_1FX5:m_2_;c1N_4_,d,V7,_n:___u;n,_:s83;_,je:Array [Boolean ,0x6_4_1_A]){} }Class _:K{Constructor (){}Var $Y,_o_e50h:N_;}'''
expect = '''Program([ClassDecl(Id(_),[MethodDecl(Id(Destructor),Instance,[],Block([])),MethodDecl(Id(Constructor),Instance,[],Block([]))]),ClassDecl(Id(k),[]),ClassDecl(Id(_6),[AttributeDecl(Instance,VarDecl(Id(k3),ClassType(Id(_)),NullLiteral())),AttributeDecl(Instance,VarDecl(Id(n),ClassType(Id(_)),NullLiteral())),AttributeDecl(Instance,VarDecl(Id(__),ClassType(Id(_)),NullLiteral())),AttributeDecl(Static,VarDecl(Id($2),ClassType(Id(_)),NullLiteral()))]),ClassDecl(Id(_),Id(____),[MethodDecl(Id(Destructor),Instance,[],Block([])),AttributeDecl(Instance,VarDecl(Id(d),ArrayType(55,ArrayType(7,FloatType)))),AttributeDecl(Instance,ConstDecl(Id(_d_1v),ArrayType(72,ArrayType(94,FloatType)),None))]),ClassDecl(Id(y__0_),Id(n),[MethodDecl(Id(f),Instance,[param(Id(D5),ArrayType(1,StringType)),param(Id(_),ArrayType(1,StringType)),param(Id(_),ClassType(Id(_))),param(Id(bp),ClassType(Id(_))),param(Id(_),ClassType(Id(_))),param(Id(_1FX5),ClassType(Id(m_2_))),param(Id(c1N_4_),ClassType(Id(___u))),param(Id(d),ClassType(Id(___u))),param(Id(V7),ClassType(Id(___u))),param(Id(_n),ClassType(Id(___u))),param(Id(n),ClassType(Id(s83))),param(Id(_),ClassType(Id(s83))),param(Id(_),ArrayType(25626,BoolType)),param(Id(je),ArrayType(25626,BoolType))],Block([]))]),ClassDecl(Id(_),Id(K),[MethodDecl(Id(Constructor),Instance,[],Block([])),AttributeDecl(Static,VarDecl(Id($Y),ClassType(Id(N_)),NullLiteral())),AttributeDecl(Instance,VarDecl(Id(_o_e50h),ClassType(Id(N_)),NullLiteral()))])])'''
self.assertTrue(TestAST.test(line, expect, 25))

def test_26(self):
line = '''Class H{}Class _u{}Class L_:x__{}Class v{_(_,_1,W:_;V06:Array [Array [Array [Array [Array [Array [Array [Int ,3],0b1010110],2],05],05],0x8],0B11_0]){} }Class __:__{}Class _{Var p_,__,h17:TX_;}Class s_v{}Class fi9__:q{}'''
expect = '''Program([ClassDecl(Id(H),[]),ClassDecl(Id(_u),[]),ClassDecl(Id(L_),Id(x__),[]),ClassDecl(Id(v),[MethodDecl(Id(_),Instance,[param(Id(_),ClassType(Id(_))),param(Id(_1),ClassType(Id(_))),param(Id(W),ClassType(Id(_))),param(Id(V06),ArrayType(6,ArrayType(8,ArrayType(5,ArrayType(5,ArrayType(2,ArrayType(86,ArrayType(3,IntType))))))))],Block([]))]),ClassDecl(Id(__),Id(__),[]),ClassDecl(Id(_),[AttributeDecl(Instance,VarDecl(Id(p_),ClassType(Id(TX_)),NullLiteral())),AttributeDecl(Instance,VarDecl(Id(__),ClassType(Id(TX_)),NullLiteral())),AttributeDecl(Instance,VarDecl(Id(h17),ClassType(Id(TX_)),NullLiteral()))]),ClassDecl(Id(s_v),[]),ClassDecl(Id(fi9__),Id(q),[])])'''
self.assertTrue(TestAST.test(line, expect, 26))

def test_27(self):
line = '''Class _:dS{$_(_:Array [Int ,0X3_32_DE_2];_,_,X,_,_:Float ;_B:Array [Array [Array [Array [Float ,3],060],2],24]){}Val $fZ7,_:Array [Array [Array [Array [Boolean ,0X7],24],0X25],24];c(uZ:String ){Return ;Continue ;Continue ;Var s0_,_y:Float ;}Val $_,$0:Float ;}'''
expect = '''Program([ClassDecl(Id(_),Id(dS),[MethodDecl(Id($_),Static,[param(Id(_),ArrayType(3354082,IntType)),param(Id(_),FloatType),param(Id(_),FloatType),param(Id(X),FloatType),param(Id(_),FloatType),param(Id(_),FloatType),param(Id(_B),ArrayType(24,ArrayType(2,ArrayType(48,ArrayType(3,FloatType)))))],Block([])),AttributeDecl(Static,ConstDecl(Id($fZ7),ArrayType(24,ArrayType(37,ArrayType(24,ArrayType(7,BoolType)))),None)),AttributeDecl(Instance,ConstDecl(Id(_),ArrayType(24,ArrayType(37,ArrayType(24,ArrayType(7,BoolType)))),None)),MethodDecl(Id(c),Instance,[param(Id(uZ),StringType)],Block([Return(),Continue,Continue,VarDecl(Id(s0_),FloatType),VarDecl(Id(_y),FloatType)])),AttributeDecl(Static,ConstDecl(Id($_),FloatType,None)),AttributeDecl(Static,ConstDecl(Id($0),FloatType,None))])])'''
self.assertTrue(TestAST.test(line, expect, 27))

def test_28(self):
line = '''Class _{Destructor (){} }Class g_:_67R1{}Class E:_K{}Class m{Var $7g80:_TY;$_(T6:Array [Array [String ,0b1],0X17];PY:Array [Array [Int ,0X17],63];_,_41_1,M_:Int ){Break ;}Constructor (){}Val $Y:Array [Array [Float ,0X17],63];Constructor (_,A,bm8:Array [Array [Boolean ,0XF],0B1_10_0_0111];__:Int ;_:Array [Array [Array [Int ,0x8],0B1],0XE0E_7]){_::$7._6();} }'''
expect = '''Program([ClassDecl(Id(_),[MethodDecl(Id(Destructor),Instance,[],Block([]))]),ClassDecl(Id(g_),Id(_67R1),[]),ClassDecl(Id(E),Id(_K),[]),ClassDecl(Id(m),[AttributeDecl(Static,VarDecl(Id($7g80),ClassType(Id(_TY)),NullLiteral())),MethodDecl(Id($_),Static,[param(Id(T6),ArrayType(23,ArrayType(1,StringType))),param(Id(PY),ArrayType(63,ArrayType(23,IntType))),param(Id(_),IntType),param(Id(_41_1),IntType),param(Id(M_),IntType)],Block([Break])),MethodDecl(Id(Constructor),Instance,[],Block([])),AttributeDecl(Static,ConstDecl(Id($Y),ArrayType(63,ArrayType(23,FloatType)),None)),MethodDecl(Id(Constructor),Instance,[param(Id(_),ArrayType(199,ArrayType(15,BoolType))),param(Id(A),ArrayType(199,ArrayType(15,BoolType))),param(Id(bm8),ArrayType(199,ArrayType(15,BoolType))),param(Id(__),IntType),param(Id(_),ArrayType(57575,ArrayType(1,ArrayType(8,IntType))))],Block([Call(FieldAccess(Id(_),Id($7)),Id(_6),[])]))])])'''
self.assertTrue(TestAST.test(line, expect, 28))

def test_29(self):
line = '''Class _:_{Destructor (){} }Class U_{Var _:_;Val $_,_,$U,$0,_,$0,M:Array [Boolean ,05];_(__:Boolean ;S:G;CL_,_,s59,_v9,_6,_:Array [Array [Boolean ,074],0x81_F_7];_,_,n___Z,_7:Array [Array [Boolean ,0b10],0X3]){Break ;}_5a5_(_,RO_:Array [String ,04];_82_,l,_7:W){Val qA:_6;Break ;} }Class _2f:k{}'''
expect = '''Program([ClassDecl(Id(_),Id(_),[MethodDecl(Id(Destructor),Instance,[],Block([]))]),ClassDecl(Id(U_),[AttributeDecl(Instance,VarDecl(Id(_),ClassType(Id(_)),NullLiteral())),AttributeDecl(Static,ConstDecl(Id($_),ArrayType(5,BoolType),None)),AttributeDecl(Instance,ConstDecl(Id(_),ArrayType(5,BoolType),None)),AttributeDecl(Static,ConstDecl(Id($U),ArrayType(5,BoolType),None)),AttributeDecl(Static,ConstDecl(Id($0),ArrayType(5,BoolType),None)),AttributeDecl(Instance,ConstDecl(Id(_),ArrayType(5,BoolType),None)),AttributeDecl(Static,ConstDecl(Id($0),ArrayType(5,BoolType),None)),AttributeDecl(Instance,ConstDecl(Id(M),ArrayType(5,BoolType),None)),MethodDecl(Id(_),Instance,[param(Id(__),BoolType),param(Id(S),ClassType(Id(G))),param(Id(CL_),ArrayType(33271,ArrayType(60,BoolType))),param(Id(_),ArrayType(33271,ArrayType(60,BoolType))),param(Id(s59),ArrayType(33271,ArrayType(60,BoolType))),param(Id(_v9),ArrayType(33271,ArrayType(60,BoolType))),param(Id(_6),ArrayType(33271,ArrayType(60,BoolType))),param(Id(_),ArrayType(33271,ArrayType(60,BoolType))),param(Id(_),ArrayType(3,ArrayType(2,BoolType))),param(Id(_),ArrayType(3,ArrayType(2,BoolType))),param(Id(n___Z),ArrayType(3,ArrayType(2,BoolType))),param(Id(_7),ArrayType(3,ArrayType(2,BoolType)))],Block([Break])),MethodDecl(Id(_5a5_),Instance,[param(Id(_),ArrayType(4,StringType)),param(Id(RO_),ArrayType(4,StringType)),param(Id(_82_),ClassType(Id(W))),param(Id(l),ClassType(Id(W))),param(Id(_7),ClassType(Id(W)))],Block([ConstDecl(Id(qA),ClassType(Id(_6)),NullLiteral()),Break]))]),ClassDecl(Id(_2f),Id(k),[])])'''
self.assertTrue(TestAST.test(line, expect, 29))

def test_30(self):
line = '''Class ___:Z{}Class f8:G{Destructor (){}Var E8,$_,$6Y9,_:d2;Constructor (){ {Continue ;} }w(__:Boolean ;_:Float ){Break ;} }Class _37_{Val k_,$Cl__zhR_:_8;}Class _{}Class _0{}'''
expect = '''Program([ClassDecl(Id(___),Id(Z),[]),ClassDecl(Id(f8),Id(G),[MethodDecl(Id(Destructor),Instance,[],Block([])),AttributeDecl(Instance,VarDecl(Id(E8),ClassType(Id(d2)),NullLiteral())),AttributeDecl(Static,VarDecl(Id($_),ClassType(Id(d2)),NullLiteral())),AttributeDecl(Static,VarDecl(Id($6Y9),ClassType(Id(d2)),NullLiteral())),AttributeDecl(Instance,VarDecl(Id(_),ClassType(Id(d2)),NullLiteral())),MethodDecl(Id(Constructor),Instance,[],Block([Block([Continue])])),MethodDecl(Id(w),Instance,[param(Id(__),BoolType),param(Id(_),FloatType)],Block([Break]))]),ClassDecl(Id(_37_),[AttributeDecl(Instance,ConstDecl(Id(k_),ClassType(Id(_8)),NullLiteral())),AttributeDecl(Static,ConstDecl(Id($Cl__zhR_),ClassType(Id(_8)),NullLiteral()))]),ClassDecl(Id(_),[]),ClassDecl(Id(_0),[])])'''
self.assertTrue(TestAST.test(line, expect, 30))

def test_31(self):
line = '''Class K3:W{Constructor (J:String ;_,v_,_:Boolean ){New _T1().__();} }Class X:r{Constructor (_m7__,_U6,_,EL_,_,wA:_9;a1_T,k9,fZvH:Array [Array [Array [String ,0x30],75],0B1];_,zU:String ;_:String ){}Constructor (){} }'''
expect = '''Program([ClassDecl(Id(K3),Id(W),[MethodDecl(Id(Constructor),Instance,[param(Id(J),StringType),param(Id(_),BoolType),param(Id(v_),BoolType),param(Id(_),BoolType)],Block([Call(NewExpr(Id(_T1),[]),Id(__),[])]))]),ClassDecl(Id(X),Id(r),[MethodDecl(Id(Constructor),Instance,[param(Id(_m7__),ClassType(Id(_9))),param(Id(_U6),ClassType(Id(_9))),param(Id(_),ClassType(Id(_9))),param(Id(EL_),ClassType(Id(_9))),param(Id(_),ClassType(Id(_9))),param(Id(wA),ClassType(Id(_9))),param(Id(a1_T),ArrayType(1,ArrayType(75,ArrayType(48,StringType)))),param(Id(k9),ArrayType(1,ArrayType(75,ArrayType(48,StringType)))),param(Id(fZvH),ArrayType(1,ArrayType(75,ArrayType(48,StringType)))),param(Id(_),StringType),param(Id(zU),StringType),param(Id(_),StringType)],Block([])),MethodDecl(Id(Constructor),Instance,[],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 31))

def test_32(self):
line = '''Class _B{Var d,$0,E_9,Su,V3:Array [Array [Array [Array [String ,0b1010111],02],0x57],98];Var $_:Array [Boolean ,06_65_1];}Class _4:o{$Y(_1q1:_;___:A;U__6t:Array [Boolean ,0x57];_:Float ){} }'''
expect = '''Program([ClassDecl(Id(_B),[AttributeDecl(Instance,VarDecl(Id(d),ArrayType(98,ArrayType(87,ArrayType(2,ArrayType(87,StringType)))))),AttributeDecl(Static,VarDecl(Id($0),ArrayType(98,ArrayType(87,ArrayType(2,ArrayType(87,StringType)))))),AttributeDecl(Instance,VarDecl(Id(E_9),ArrayType(98,ArrayType(87,ArrayType(2,ArrayType(87,StringType)))))),AttributeDecl(Instance,VarDecl(Id(Su),ArrayType(98,ArrayType(87,ArrayType(2,ArrayType(87,StringType)))))),AttributeDecl(Instance,VarDecl(Id(V3),ArrayType(98,ArrayType(87,ArrayType(2,ArrayType(87,StringType)))))),AttributeDecl(Static,VarDecl(Id($_),ArrayType(3497,BoolType)))]),ClassDecl(Id(_4),Id(o),[MethodDecl(Id($Y),Static,[param(Id(_1q1),ClassType(Id(_))),param(Id(___),ClassType(Id(A))),param(Id(U__6t),ArrayType(87,BoolType)),param(Id(_),FloatType)],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 32))

def test_33(self):
line = '''Class _{}Class _i:J_{Var I:Int ;}Class _9_Y:N{}Class f9:c_{$vw(){}Constructor (_9,u__,_LJ:Array [Array [Array [Boolean ,0X5B_55],0X2D],21];n_:Array [String ,0b1010010];Op,__,_O:_3kID3_){}$o(_:_;_,_,_C:Array [String ,21];_9_,z:Array [String ,0b1_1]){} }Class m__{Destructor (){} }Class _t{}Class xGu6:b{Var $N_,$_V:Float ;Destructor (){} }'''
expect = '''Program([ClassDecl(Id(_),[]),ClassDecl(Id(_i),Id(J_),[AttributeDecl(Instance,VarDecl(Id(I),IntType))]),ClassDecl(Id(_9_Y),Id(N),[]),ClassDecl(Id(f9),Id(c_),[MethodDecl(Id($vw),Static,[],Block([])),MethodDecl(Id(Constructor),Instance,[param(Id(_9),ArrayType(21,ArrayType(45,ArrayType(23381,BoolType)))),param(Id(u__),ArrayType(21,ArrayType(45,ArrayType(23381,BoolType)))),param(Id(_LJ),ArrayType(21,ArrayType(45,ArrayType(23381,BoolType)))),param(Id(n_),ArrayType(82,StringType)),param(Id(Op),ClassType(Id(_3kID3_))),param(Id(__),ClassType(Id(_3kID3_))),param(Id(_O),ClassType(Id(_3kID3_)))],Block([])),MethodDecl(Id($o),Static,[param(Id(_),ClassType(Id(_))),param(Id(_),ArrayType(21,StringType)),param(Id(_),ArrayType(21,StringType)),param(Id(_C),ArrayType(21,StringType)),param(Id(_9_),ArrayType(3,StringType)),param(Id(z),ArrayType(3,StringType))],Block([]))]),ClassDecl(Id(m__),[MethodDecl(Id(Destructor),Instance,[],Block([]))]),ClassDecl(Id(_t),[]),ClassDecl(Id(xGu6),Id(b),[AttributeDecl(Static,VarDecl(Id($N_),FloatType)),AttributeDecl(Static,VarDecl(Id($_V),FloatType)),MethodDecl(Id(Destructor),Instance,[],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 33))

def test_34(self):
line = '''Class J8YV3{Destructor (){}Val _R:Boolean ;Constructor (uk,_1_,F,n,__,_8,_:_;b:K;E:Array [Array [Array [Array [Array [Array [Array [Array [String ,03],07],0XE_49_D_E_B_F],47],0B1],0B1100001],0b1_000],0111]){Continue ;} }'''
expect = '''Program([ClassDecl(Id(J8YV3),[MethodDecl(Id(Destructor),Instance,[],Block([])),AttributeDecl(Instance,ConstDecl(Id(_R),BoolType,None)),MethodDecl(Id(Constructor),Instance,[param(Id(uk),ClassType(Id(_))),param(Id(_1_),ClassType(Id(_))),param(Id(F),ClassType(Id(_))),param(Id(n),ClassType(Id(_))),param(Id(__),ClassType(Id(_))),param(Id(_8),ClassType(Id(_))),param(Id(_),ClassType(Id(_))),param(Id(b),ClassType(Id(K))),param(Id(E),ArrayType(73,ArrayType(8,ArrayType(97,ArrayType(1,ArrayType(47,ArrayType(239722175,ArrayType(7,ArrayType(3,StringType)))))))))],Block([Continue]))])])'''
self.assertTrue(TestAST.test(line, expect, 34))

def test_35(self):
line = '''Class _b{Constructor (_2_:Float ;__:k;_41:Array [Array [Float ,06],2];_,l,W1:_){}Val I9Z,$h,$T:Array [Array [Float ,0X8_F],0b1011010];}Class h_A___{}Class y1{}Class Ex2_:K{}'''
expect = '''Program([ClassDecl(Id(_b),[MethodDecl(Id(Constructor),Instance,[param(Id(_2_),FloatType),param(Id(__),ClassType(Id(k))),param(Id(_41),ArrayType(2,ArrayType(6,FloatType))),param(Id(_),ClassType(Id(_))),param(Id(l),ClassType(Id(_))),param(Id(W1),ClassType(Id(_)))],Block([])),AttributeDecl(Instance,ConstDecl(Id(I9Z),ArrayType(90,ArrayType(143,FloatType)),None)),AttributeDecl(Static,ConstDecl(Id($h),ArrayType(90,ArrayType(143,FloatType)),None)),AttributeDecl(Static,ConstDecl(Id($T),ArrayType(90,ArrayType(143,FloatType)),None))]),ClassDecl(Id(h_A___),[]),ClassDecl(Id(y1),[]),ClassDecl(Id(Ex2_),Id(K),[])])'''
self.assertTrue(TestAST.test(line, expect, 35))

def test_36(self):
line = '''Class w_:__{}Class H5_:__{Destructor (){}Constructor (S_M,_A:Array [Array [Boolean ,063],07_0];_,_6:Float ;d6:_;_,_HZ,E,_,g,U_,_:Array [String ,0X1]){Break ;}Var x7,$3_:Array [Float ,15];}'''
expect = '''Program([ClassDecl(Id(w_),Id(__),[]),ClassDecl(Id(H5_),Id(__),[MethodDecl(Id(Destructor),Instance,[],Block([])),MethodDecl(Id(Constructor),Instance,[param(Id(S_M),ArrayType(56,ArrayType(51,BoolType))),param(Id(_A),ArrayType(56,ArrayType(51,BoolType))),param(Id(_),FloatType),param(Id(_6),FloatType),param(Id(d6),ClassType(Id(_))),param(Id(_),ArrayType(1,StringType)),param(Id(_HZ),ArrayType(1,StringType)),param(Id(E),ArrayType(1,StringType)),param(Id(_),ArrayType(1,StringType)),param(Id(g),ArrayType(1,StringType)),param(Id(U_),ArrayType(1,StringType)),param(Id(_),ArrayType(1,StringType))],Block([Break])),AttributeDecl(Instance,VarDecl(Id(x7),ArrayType(15,FloatType))),AttributeDecl(Static,VarDecl(Id($3_),ArrayType(15,FloatType)))])])'''
self.assertTrue(TestAST.test(line, expect, 36))

def test_37(self):
line = '''Class _:z9{Val $__4:_;}Class i_{Destructor (){Val DS_,_:Array [Array [Boolean ,94],0X1_4];} }Class u:u{Destructor (){}Val $i:Float ;Constructor (){}Var c2pc_:_;}Class v{}'''
expect = '''Program([ClassDecl(Id(_),Id(z9),[AttributeDecl(Static,ConstDecl(Id($__4),ClassType(Id(_)),NullLiteral()))]),ClassDecl(Id(i_),[MethodDecl(Id(Destructor),Instance,[],Block([ConstDecl(Id(DS_),ArrayType(20,ArrayType(94,BoolType)),None),ConstDecl(Id(_),ArrayType(20,ArrayType(94,BoolType)),None)]))]),ClassDecl(Id(u),Id(u),[MethodDecl(Id(Destructor),Instance,[],Block([])),AttributeDecl(Static,ConstDecl(Id($i),FloatType,None)),MethodDecl(Id(Constructor),Instance,[],Block([])),AttributeDecl(Instance,VarDecl(Id(c2pc_),ClassType(Id(_)),NullLiteral()))]),ClassDecl(Id(v),[])])'''
self.assertTrue(TestAST.test(line, expect, 37))

def test_38(self):
line = '''Class B:I{$353(I__,Jr:Boolean ;E:Array [Array [Array [Boolean ,56],2],041];_:Array [Array [Array [Float ,06_0],56],7]){} }Class H_x_J{Constructor (){Continue ;{} }$30VF2(){}Val J,$_:_24;}Class H:c_{Val $X_48:String ;}'''
expect = '''Program([ClassDecl(Id(B),Id(I),[MethodDecl(Id($353),Static,[param(Id(I__),BoolType),param(Id(Jr),BoolType),param(Id(E),ArrayType(33,ArrayType(2,ArrayType(56,BoolType)))),param(Id(_),ArrayType(7,ArrayType(56,ArrayType(48,FloatType))))],Block([]))]),ClassDecl(Id(H_x_J),[MethodDecl(Id(Constructor),Instance,[],Block([Continue,Block([])])),MethodDecl(Id($30VF2),Static,[],Block([])),AttributeDecl(Instance,ConstDecl(Id(J),ClassType(Id(_24)),NullLiteral())),AttributeDecl(Static,ConstDecl(Id($_),ClassType(Id(_24)),NullLiteral()))]),ClassDecl(Id(H),Id(c_),[AttributeDecl(Static,ConstDecl(Id($X_48),StringType,None))])])'''
self.assertTrue(TestAST.test(line, expect, 38))

def test_39(self):
line = '''Class l:Q{$US(__,_,e7,_:Float ;f:_;_4,Mh:String ;_9f_:Boolean ;z:_Xw){}Var X:w__;}Class _{$x_(V2_,___T:Array [Array [Boolean ,0b10110],0X38];w_,__,_:_e;cIew:Float ){Break ;} }'''
expect = '''Program([ClassDecl(Id(l),Id(Q),[MethodDecl(Id($US),Static,[param(Id(__),FloatType),param(Id(_),FloatType),param(Id(e7),FloatType),param(Id(_),FloatType),param(Id(f),ClassType(Id(_))),param(Id(_4),StringType),param(Id(Mh),StringType),param(Id(_9f_),BoolType),param(Id(z),ClassType(Id(_Xw)))],Block([])),AttributeDecl(Instance,VarDecl(Id(X),ClassType(Id(w__)),NullLiteral()))]),ClassDecl(Id(_),[MethodDecl(Id($x_),Static,[param(Id(V2_),ArrayType(56,ArrayType(22,BoolType))),param(Id(___T),ArrayType(56,ArrayType(22,BoolType))),param(Id(w_),ClassType(Id(_e))),param(Id(__),ClassType(Id(_e))),param(Id(_),ClassType(Id(_e))),param(Id(cIew),FloatType)],Block([Break]))])])'''
self.assertTrue(TestAST.test(line, expect, 39))

def test_40(self):
line = '''Class FW{Constructor (_,B:Float ;h_4_1:_w;w_:_;p__,_:z){}Constructor (Z,_3IC,_,_ov,B,G:Array [Array [Boolean ,0x61],0B1011];d,_:Array [Array [Array [Array [String ,0b100111],0xAD],0x61],0b10]){} }Class _2{}'''
expect = '''Program([ClassDecl(Id(FW),[MethodDecl(Id(Constructor),Instance,[param(Id(_),FloatType),param(Id(B),FloatType),param(Id(h_4_1),ClassType(Id(_w))),param(Id(w_),ClassType(Id(_))),param(Id(p__),ClassType(Id(z))),param(Id(_),ClassType(Id(z)))],Block([])),MethodDecl(Id(Constructor),Instance,[param(Id(Z),ArrayType(11,ArrayType(97,BoolType))),param(Id(_3IC),ArrayType(11,ArrayType(97,BoolType))),param(Id(_),ArrayType(11,ArrayType(97,BoolType))),param(Id(_ov),ArrayType(11,ArrayType(97,BoolType))),param(Id(B),ArrayType(11,ArrayType(97,BoolType))),param(Id(G),ArrayType(11,ArrayType(97,BoolType))),param(Id(d),ArrayType(2,ArrayType(97,ArrayType(173,ArrayType(39,StringType))))),param(Id(_),ArrayType(2,ArrayType(97,ArrayType(173,ArrayType(39,StringType)))))],Block([]))]),ClassDecl(Id(_2),[])])'''
self.assertTrue(TestAST.test(line, expect, 40))

def test_41(self):
line = '''Class m_q{}Class q18:k1Q_3{Val _,$_r:String ;Val _7__:Array [Array [Array [Array [Array [Array [Array [Array [Boolean ,6],8],0B1_1],0X2B8],6],0X5D],6],2_6];Val _,$9_,$_2,_:_dT4;Constructor (){Continue ;} }Class e_{}Class _:L1{Var $y:T;}Class S{Constructor (_:_){} }Class _1{}Class _6:_{Destructor (){} }Class _:b0{}'''
expect = '''Program([ClassDecl(Id(m_q),[]),ClassDecl(Id(q18),Id(k1Q_3),[AttributeDecl(Instance,ConstDecl(Id(_),StringType,None)),AttributeDecl(Static,ConstDecl(Id($_r),StringType,None)),AttributeDecl(Instance,ConstDecl(Id(_7__),ArrayType(26,ArrayType(6,ArrayType(93,ArrayType(6,ArrayType(696,ArrayType(3,ArrayType(8,ArrayType(6,BoolType)))))))),None)),AttributeDecl(Instance,ConstDecl(Id(_),ClassType(Id(_dT4)),NullLiteral())),AttributeDecl(Static,ConstDecl(Id($9_),ClassType(Id(_dT4)),NullLiteral())),AttributeDecl(Static,ConstDecl(Id($_2),ClassType(Id(_dT4)),NullLiteral())),AttributeDecl(Instance,ConstDecl(Id(_),ClassType(Id(_dT4)),NullLiteral())),MethodDecl(Id(Constructor),Instance,[],Block([Continue]))]),ClassDecl(Id(e_),[]),ClassDecl(Id(_),Id(L1),[AttributeDecl(Static,VarDecl(Id($y),ClassType(Id(T)),NullLiteral()))]),ClassDecl(Id(S),[MethodDecl(Id(Constructor),Instance,[param(Id(_),ClassType(Id(_)))],Block([]))]),ClassDecl(Id(_1),[]),ClassDecl(Id(_6),Id(_),[MethodDecl(Id(Destructor),Instance,[],Block([]))]),ClassDecl(Id(_),Id(b0),[])])'''
self.assertTrue(TestAST.test(line, expect, 41))

def test_42(self):
line = '''Class g_:_{Constructor (__m2f:Array [Array [Float ,9_1_3],052]){}Constructor (q_:Array [Boolean ,0X56];__:F_;Y:Array [Array [Array [Boolean ,0B100],07],06];_,_N,F:_){} }Class ot:ZJS_qH{}Class v_:v14{}Class Y:_{}'''
expect = '''Program([ClassDecl(Id(g_),Id(_),[MethodDecl(Id(Constructor),Instance,[param(Id(__m2f),ArrayType(42,ArrayType(913,FloatType)))],Block([])),MethodDecl(Id(Constructor),Instance,[param(Id(q_),ArrayType(86,BoolType)),param(Id(__),ClassType(Id(F_))),param(Id(Y),ArrayType(6,ArrayType(7,ArrayType(4,BoolType)))),param(Id(_),ClassType(Id(_))),param(Id(_N),ClassType(Id(_))),param(Id(F),ClassType(Id(_)))],Block([]))]),ClassDecl(Id(ot),Id(ZJS_qH),[]),ClassDecl(Id(v_),Id(v14),[]),ClassDecl(Id(Y),Id(_),[])])'''
self.assertTrue(TestAST.test(line, expect, 42))

def test_43(self):
line = '''Class _8{Val $7L,$E2,_2r_a:Array [Array [Boolean ,6_5_6_1_7],01_4_5_022];}Class _{Var $3,$Y_l:Array [Boolean ,0B11_0];}Class e_{}Class _Q_:_{Destructor (){} }Class _O_{$H_(){} }Class __:g{__(_b_,__5:_;X__,F2___4:Zq){} }'''
expect = '''Program([ClassDecl(Id(_8),[AttributeDecl(Static,ConstDecl(Id($7L),ArrayType(51730,ArrayType(65617,BoolType)),None)),AttributeDecl(Static,ConstDecl(Id($E2),ArrayType(51730,ArrayType(65617,BoolType)),None)),AttributeDecl(Instance,ConstDecl(Id(_2r_a),ArrayType(51730,ArrayType(65617,BoolType)),None))]),ClassDecl(Id(_),[AttributeDecl(Static,VarDecl(Id($3),ArrayType(6,BoolType))),AttributeDecl(Static,VarDecl(Id($Y_l),ArrayType(6,BoolType)))]),ClassDecl(Id(e_),[]),ClassDecl(Id(_Q_),Id(_),[MethodDecl(Id(Destructor),Instance,[],Block([]))]),ClassDecl(Id(_O_),[MethodDecl(Id($H_),Static,[],Block([]))]),ClassDecl(Id(__),Id(g),[MethodDecl(Id(__),Instance,[param(Id(_b_),ClassType(Id(_))),param(Id(__5),ClassType(Id(_))),param(Id(X__),ClassType(Id(Zq))),param(Id(F2___4),ClassType(Id(Zq)))],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 43))

def test_44(self):
line = '''Class _0{$R(Jb,U_:_){Break ;Continue ;}Constructor (s,_:Array [Array [Array [Array [Float ,041],30],0X10_B5],0B101101];_F:m;__4bwH,k,_H_:__){Break ;}Var $99_,i__,$I_:Array [Array [Int ,0x5],7_82_9_9_10_9_1_1_3];}'''
expect = '''Program([ClassDecl(Id(_0),[MethodDecl(Id($R),Static,[param(Id(Jb),ClassType(Id(_))),param(Id(U_),ClassType(Id(_)))],Block([Break,Continue])),MethodDecl(Id(Constructor),Instance,[param(Id(s),ArrayType(45,ArrayType(4277,ArrayType(30,ArrayType(33,FloatType))))),param(Id(_),ArrayType(45,ArrayType(4277,ArrayType(30,ArrayType(33,FloatType))))),param(Id(_F),ClassType(Id(m))),param(Id(__4bwH),ClassType(Id(__))),param(Id(k),ClassType(Id(__))),param(Id(_H_),ClassType(Id(__)))],Block([Break])),AttributeDecl(Static,VarDecl(Id($99_),ArrayType(78299109113,ArrayType(5,IntType)))),AttributeDecl(Instance,VarDecl(Id(i__),ArrayType(78299109113,ArrayType(5,IntType)))),AttributeDecl(Static,VarDecl(Id($I_),ArrayType(78299109113,ArrayType(5,IntType))))])])'''
self.assertTrue(TestAST.test(line, expect, 44))

def test_45(self):
line = '''Class _6{Destructor (){}Var $58RK:Int ;Val _WS,g:Array [Array [String ,0B1010000],0XC_1_C_9];}Class f{Constructor (ON,_:_;_2:Array [Array [Array [Int ,0114],0114],67]){}Destructor (){} }'''
expect = '''Program([ClassDecl(Id(_6),[MethodDecl(Id(Destructor),Instance,[],Block([])),AttributeDecl(Static,VarDecl(Id($58RK),IntType)),AttributeDecl(Instance,ConstDecl(Id(_WS),ArrayType(49609,ArrayType(80,StringType)),None)),AttributeDecl(Instance,ConstDecl(Id(g),ArrayType(49609,ArrayType(80,StringType)),None))]),ClassDecl(Id(f),[MethodDecl(Id(Constructor),Instance,[param(Id(ON),ClassType(Id(_))),param(Id(_),ClassType(Id(_))),param(Id(_2),ArrayType(67,ArrayType(76,ArrayType(76,IntType))))],Block([])),MethodDecl(Id(Destructor),Instance,[],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 45))

def test_46(self):
line = '''Class l:_{}Class _V:w_{Val $6,$48_:Array [Array [Array [Array [Float ,0X9B_8F],0xA],0B1000010],01];Var $2_:Array [String ,0B1];Var $6:Array [Array [Array [Array [Int ,93],47],0X4],7];$I1e(){}__Sl(L3:Array [Array [Array [String ,0112],414],06];_:_;r_,g,C:Float ){} }Class l{}Class C:_02R{}'''
expect = '''Program([ClassDecl(Id(l),Id(_),[]),ClassDecl(Id(_V),Id(w_),[AttributeDecl(Static,ConstDecl(Id($6),ArrayType(1,ArrayType(66,ArrayType(10,ArrayType(39823,FloatType)))),None)),AttributeDecl(Static,ConstDecl(Id($48_),ArrayType(1,ArrayType(66,ArrayType(10,ArrayType(39823,FloatType)))),None)),AttributeDecl(Static,VarDecl(Id($2_),ArrayType(1,StringType))),AttributeDecl(Static,VarDecl(Id($6),ArrayType(7,ArrayType(4,ArrayType(47,ArrayType(93,IntType)))))),MethodDecl(Id($I1e),Static,[],Block([])),MethodDecl(Id(__Sl),Instance,[param(Id(L3),ArrayType(6,ArrayType(414,ArrayType(74,StringType)))),param(Id(_),ClassType(Id(_))),param(Id(r_),FloatType),param(Id(g),FloatType),param(Id(C),FloatType)],Block([]))]),ClassDecl(Id(l),[]),ClassDecl(Id(C),Id(_02R),[])])'''
self.assertTrue(TestAST.test(line, expect, 46))

def test_47(self):
line = '''Class _:_15{o(_IJ:Int ;E:Array [Boolean ,0B10];U,XL:Boolean ){}Destructor (){ {} }Val $Y2_:k;Constructor (e_4_3:Array [Array [Array [Float ,8],03],07];_S:w_8;_2:Array [Int ,91]){} }'''
expect = '''Program([ClassDecl(Id(_),Id(_15),[MethodDecl(Id(o),Instance,[param(Id(_IJ),IntType),param(Id(E),ArrayType(2,BoolType)),param(Id(U),BoolType),param(Id(XL),BoolType)],Block([])),MethodDecl(Id(Destructor),Instance,[],Block([Block([])])),AttributeDecl(Static,ConstDecl(Id($Y2_),ClassType(Id(k)),NullLiteral())),MethodDecl(Id(Constructor),Instance,[param(Id(e_4_3),ArrayType(7,ArrayType(3,ArrayType(8,FloatType)))),param(Id(_S),ClassType(Id(w_8))),param(Id(_2),ArrayType(91,IntType))],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 47))

def test_48(self):
line = '''Class __P_{}Class v5Y2K_{Val $__,$_8,$__z:Boolean ;}Class _a:_{Constructor (J3i2,K:_9;_:C){}Val $_,$__,$t_:String ;Constructor (_gF4k,_x:Array [Array [Float ,6_6_4_68],1_5]){Break ;} }Class _:Z{Val _,_,t,__76,$8,o:String ;}Class __:vE{}Class _{}Class x__0:_J9B{}Class _:_{}Class Ce:Bg__3{}'''
expect = '''Program([ClassDecl(Id(__P_),[]),ClassDecl(Id(v5Y2K_),[AttributeDecl(Static,ConstDecl(Id($__),BoolType,None)),AttributeDecl(Static,ConstDecl(Id($_8),BoolType,None)),AttributeDecl(Static,ConstDecl(Id($__z),BoolType,None))]),ClassDecl(Id(_a),Id(_),[MethodDecl(Id(Constructor),Instance,[param(Id(J3i2),ClassType(Id(_9))),param(Id(K),ClassType(Id(_9))),param(Id(_),ClassType(Id(C)))],Block([])),AttributeDecl(Static,ConstDecl(Id($_),StringType,None)),AttributeDecl(Static,ConstDecl(Id($__),StringType,None)),AttributeDecl(Static,ConstDecl(Id($t_),StringType,None)),MethodDecl(Id(Constructor),Instance,[param(Id(_gF4k),ArrayType(15,ArrayType(66468,FloatType))),param(Id(_x),ArrayType(15,ArrayType(66468,FloatType)))],Block([Break]))]),ClassDecl(Id(_),Id(Z),[AttributeDecl(Instance,ConstDecl(Id(_),StringType,None)),AttributeDecl(Instance,ConstDecl(Id(_),StringType,None)),AttributeDecl(Instance,ConstDecl(Id(t),StringType,None)),AttributeDecl(Instance,ConstDecl(Id(__76),StringType,None)),AttributeDecl(Static,ConstDecl(Id($8),StringType,None)),AttributeDecl(Instance,ConstDecl(Id(o),StringType,None))]),ClassDecl(Id(__),Id(vE),[]),ClassDecl(Id(_),[]),ClassDecl(Id(x__0),Id(_J9B),[]),ClassDecl(Id(_),Id(_),[]),ClassDecl(Id(Ce),Id(Bg__3),[])])'''
self.assertTrue(TestAST.test(line, expect, 48))

def test_49(self):
line = '''Class __:_{_(cv:Array [Array [Array [Array [String ,3],0127],0x5],06623_4];__,o,__h2:String ){}$s29(W_Eo:Array [Array [Boolean ,0B1],0127];p:A_3_;_:Int ;_,_32,_,_6n,_,C_:Array [Int ,0B111101]){} }'''
expect = '''Program([ClassDecl(Id(__),Id(_),[MethodDecl(Id(_),Instance,[param(Id(cv),ArrayType(27804,ArrayType(5,ArrayType(87,ArrayType(3,StringType))))),param(Id(__),StringType),param(Id(o),StringType),param(Id(__h2),StringType)],Block([])),MethodDecl(Id($s29),Static,[param(Id(W_Eo),ArrayType(87,ArrayType(1,BoolType))),param(Id(p),ClassType(Id(A_3_))),param(Id(_),IntType),param(Id(_),ArrayType(61,IntType)),param(Id(_32),ArrayType(61,IntType)),param(Id(_),ArrayType(61,IntType)),param(Id(_6n),ArrayType(61,IntType)),param(Id(_),ArrayType(61,IntType)),param(Id(C_),ArrayType(61,IntType))],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 49))

def test_50(self):
line = '''Class _5{$4(_____,hL68,__,_,i,_:Float ;_4,_00_1_,y,n2,_fo,F_7,E:__;__:_){}Val _:Array [Array [String ,0106],580_85_73];}Class ct7{}Class _0:P26_4_{Constructor (){} }'''
expect = '''Program([ClassDecl(Id(_5),[MethodDecl(Id($4),Static,[param(Id(_____),FloatType),param(Id(hL68),FloatType),param(Id(__),FloatType),param(Id(_),FloatType),param(Id(i),FloatType),param(Id(_),FloatType),param(Id(_4),ClassType(Id(__))),param(Id(_00_1_),ClassType(Id(__))),param(Id(y),ClassType(Id(__))),param(Id(n2),ClassType(Id(__))),param(Id(_fo),ClassType(Id(__))),param(Id(F_7),ClassType(Id(__))),param(Id(E),ClassType(Id(__))),param(Id(__),ClassType(Id(_)))],Block([])),AttributeDecl(Instance,ConstDecl(Id(_),ArrayType(5808573,ArrayType(70,StringType)),None))]),ClassDecl(Id(ct7),[]),ClassDecl(Id(_0),Id(P26_4_),[MethodDecl(Id(Constructor),Instance,[],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 50))

def test_51(self):
line = '''Class _{B(){} }Class _Xu_:__3{Constructor (gs_,z:_gs;JpI:Array [Array [Array [Array [Array [Array [Float ,0x6],9],037],037],30],7_8_7_6];b,_,dHI,_Z,md35:Array [String ,0B1001100];M__,x:q4){Break ;{} }}'''
expect = '''Program([ClassDecl(Id(_),[MethodDecl(Id(B),Instance,[],Block([]))]),ClassDecl(Id(_Xu_),Id(__3),[MethodDecl(Id(Constructor),Instance,[param(Id(gs_),ClassType(Id(_gs))),param(Id(z),ClassType(Id(_gs))),param(Id(JpI),ArrayType(7876,ArrayType(30,ArrayType(31,ArrayType(31,ArrayType(9,ArrayType(6,FloatType))))))),param(Id(b),ArrayType(76,StringType)),param(Id(_),ArrayType(76,StringType)),param(Id(dHI),ArrayType(76,StringType)),param(Id(_Z),ArrayType(76,StringType)),param(Id(md35),ArrayType(76,StringType)),param(Id(M__),ClassType(Id(q4))),param(Id(x),ClassType(Id(q4)))],Block([Break,Block([])]))])])'''
self.assertTrue(TestAST.test(line, expect, 51))

def test_52(self):
line = '''Class t__J_{Constructor (a,x_1,_0:Array [Array [Array [Array [Array [Array [Array [Array [Array [Array [String ,0X6_E],0xC],0b100101],0X42],0b11_10],0xBE],023],017],9],0b100101];C:_){Continue ;} }Class h:I0{Destructor (){} }'''
expect = '''Program([ClassDecl(Id(t__J_),[MethodDecl(Id(Constructor),Instance,[param(Id(a),ArrayType(37,ArrayType(9,ArrayType(15,ArrayType(19,ArrayType(190,ArrayType(14,ArrayType(66,ArrayType(37,ArrayType(12,ArrayType(110,StringType))))))))))),param(Id(x_1),ArrayType(37,ArrayType(9,ArrayType(15,ArrayType(19,ArrayType(190,ArrayType(14,ArrayType(66,ArrayType(37,ArrayType(12,ArrayType(110,StringType))))))))))),param(Id(_0),ArrayType(37,ArrayType(9,ArrayType(15,ArrayType(19,ArrayType(190,ArrayType(14,ArrayType(66,ArrayType(37,ArrayType(12,ArrayType(110,StringType))))))))))),param(Id(C),ClassType(Id(_)))],Block([Continue]))]),ClassDecl(Id(h),Id(I0),[MethodDecl(Id(Destructor),Instance,[],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 52))

def test_53(self):
line = '''Class K{Var _:Array [Boolean ,3];}Class _{Val $_:Array [Array [Array [Array [Int ,01_5],0106],0X8_3_0],0106];hn(_,_,M6:String ){Break ;Return ;0x0.N5.__._();}Val _:String ;}'''
expect = '''Program([ClassDecl(Id(K),[AttributeDecl(Instance,VarDecl(Id(_),ArrayType(3,BoolType)))]),ClassDecl(Id(_),[AttributeDecl(Static,ConstDecl(Id($_),ArrayType(70,ArrayType(2096,ArrayType(70,ArrayType(13,IntType)))),None)),MethodDecl(Id(hn),Instance,[param(Id(_),StringType),param(Id(_),StringType),param(Id(M6),StringType)],Block([Break,Return(),Call(FieldAccess(FieldAccess(IntLit(0),Id(N5)),Id(__)),Id(_),[])])),AttributeDecl(Instance,ConstDecl(Id(_),StringType,None))])])'''
self.assertTrue(TestAST.test(line, expect, 53))

def test_54(self):
line = '''Class __:y{}Class o__23c{Constructor (){}Constructor (){}Val $J4,_1_m:Array [Boolean ,0XF];Constructor (Q:Array [Array [Array [Boolean ,037],0x64],9];_,_Y_6:M;_,K__,c1_:_){} }'''
expect = '''Program([ClassDecl(Id(__),Id(y),[]),ClassDecl(Id(o__23c),[MethodDecl(Id(Constructor),Instance,[],Block([])),MethodDecl(Id(Constructor),Instance,[],Block([])),AttributeDecl(Static,ConstDecl(Id($J4),ArrayType(15,BoolType),None)),AttributeDecl(Instance,ConstDecl(Id(_1_m),ArrayType(15,BoolType),None)),MethodDecl(Id(Constructor),Instance,[param(Id(Q),ArrayType(9,ArrayType(100,ArrayType(31,BoolType)))),param(Id(_),ClassType(Id(M))),param(Id(_Y_6),ClassType(Id(M))),param(Id(_),ClassType(Id(_))),param(Id(K__),ClassType(Id(_))),param(Id(c1_),ClassType(Id(_)))],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 54))

def test_55(self):
line = '''Class _:oC{}Class va_:_{}Class _JV9_:h3{}Class _:_{Destructor (){Val _7,_t,_:Float ;Return ;} }Class __2_{Destructor (){Var W2K,_:Array [Array [Boolean ,0X8],0X5B];{Continue ;} }}'''
expect = '''Program([ClassDecl(Id(_),Id(oC),[]),ClassDecl(Id(va_),Id(_),[]),ClassDecl(Id(_JV9_),Id(h3),[]),ClassDecl(Id(_),Id(_),[MethodDecl(Id(Destructor),Instance,[],Block([ConstDecl(Id(_7),FloatType,None),ConstDecl(Id(_t),FloatType,None),ConstDecl(Id(_),FloatType,None),Return()]))]),ClassDecl(Id(__2_),[MethodDecl(Id(Destructor),Instance,[],Block([VarDecl(Id(W2K),ArrayType(91,ArrayType(8,BoolType))),VarDecl(Id(_),ArrayType(91,ArrayType(8,BoolType))),Block([Continue])]))])])'''
self.assertTrue(TestAST.test(line, expect, 55))

def test_56(self):
line = '''Class NhAm:_{Var t_:String ;Constructor (y:_1tr;_8f:Array [Array [Float ,0b100000],0x2];E,E9_,_:String ;v,ym_k:Array [Int ,0B10001];Y,_:Array [Array [Array [Boolean ,84],0B10001],06_7]){Break ;} }'''
expect = '''Program([ClassDecl(Id(NhAm),Id(_),[AttributeDecl(Instance,VarDecl(Id(t_),StringType)),MethodDecl(Id(Constructor),Instance,[param(Id(y),ClassType(Id(_1tr))),param(Id(_8f),ArrayType(2,ArrayType(32,FloatType))),param(Id(E),StringType),param(Id(E9_),StringType),param(Id(_),StringType),param(Id(v),ArrayType(17,IntType)),param(Id(ym_k),ArrayType(17,IntType)),param(Id(Y),ArrayType(55,ArrayType(17,ArrayType(84,BoolType)))),param(Id(_),ArrayType(55,ArrayType(17,ArrayType(84,BoolType))))],Block([Break]))])])'''
self.assertTrue(TestAST.test(line, expect, 56))

def test_57(self):
line = '''Class _5{}Class _2{}Class _3U{Val _1,$q__0_D0_2,g:Float ;Constructor (_,Wx:___n;N_83l:Array [Boolean ,0b1011001];m7:Int ;i:_U;ES4O,_b__E,cx,_4:Boolean ;i,h:Array [Array [Boolean ,054],054]){Break ;}Constructor (){}Val __6E,$0:_;}'''
expect = '''Program([ClassDecl(Id(_5),[]),ClassDecl(Id(_2),[]),ClassDecl(Id(_3U),[AttributeDecl(Instance,ConstDecl(Id(_1),FloatType,None)),AttributeDecl(Static,ConstDecl(Id($q__0_D0_2),FloatType,None)),AttributeDecl(Instance,ConstDecl(Id(g),FloatType,None)),MethodDecl(Id(Constructor),Instance,[param(Id(_),ClassType(Id(___n))),param(Id(Wx),ClassType(Id(___n))),param(Id(N_83l),ArrayType(89,BoolType)),param(Id(m7),IntType),param(Id(i),ClassType(Id(_U))),param(Id(ES4O),BoolType),param(Id(_b__E),BoolType),param(Id(cx),BoolType),param(Id(_4),BoolType),param(Id(i),ArrayType(44,ArrayType(44,BoolType))),param(Id(h),ArrayType(44,ArrayType(44,BoolType)))],Block([Break])),MethodDecl(Id(Constructor),Instance,[],Block([])),AttributeDecl(Instance,ConstDecl(Id(__6E),ClassType(Id(_)),NullLiteral())),AttributeDecl(Static,ConstDecl(Id($0),ClassType(Id(_)),NullLiteral()))])])'''
self.assertTrue(TestAST.test(line, expect, 57))

def test_58(self):
line = '''Class f:k__{Var $__,$_,p4,$Q39:Boolean ;}Class ___:y2{}Class _y_0:__8{Var n,s_6I9,_,$m__:Int ;Constructor (__z:Int ;_:Boolean ;hz:Array [Array [Boolean ,0b1100010],024];o,_y,__,lx:b){Return ;} }Class _{Var _:String ;}'''
expect = '''Program([ClassDecl(Id(f),Id(k__),[AttributeDecl(Static,VarDecl(Id($__),BoolType)),AttributeDecl(Static,VarDecl(Id($_),BoolType)),AttributeDecl(Instance,VarDecl(Id(p4),BoolType)),AttributeDecl(Static,VarDecl(Id($Q39),BoolType))]),ClassDecl(Id(___),Id(y2),[]),ClassDecl(Id(_y_0),Id(__8),[AttributeDecl(Instance,VarDecl(Id(n),IntType)),AttributeDecl(Instance,VarDecl(Id(s_6I9),IntType)),AttributeDecl(Instance,VarDecl(Id(_),IntType)),AttributeDecl(Static,VarDecl(Id($m__),IntType)),MethodDecl(Id(Constructor),Instance,[param(Id(__z),IntType),param(Id(_),BoolType),param(Id(hz),ArrayType(20,ArrayType(98,BoolType))),param(Id(o),ClassType(Id(b))),param(Id(_y),ClassType(Id(b))),param(Id(__),ClassType(Id(b))),param(Id(lx),ClassType(Id(b)))],Block([Return()]))]),ClassDecl(Id(_),[AttributeDecl(Instance,VarDecl(Id(_),StringType))])])'''
self.assertTrue(TestAST.test(line, expect, 58))

def test_59(self):
line = '''Class _:_{k_(__:Int ;V3_:Int ;e_,___5ty,f5:Boolean ;N8Et,_,_164,G:_K__){New _I().d();}Val W,_:Array [Array [Array [Array [Array [Int ,81],060],81],044],0X63];Val $_i,$_:_;Constructor (_:__6){} }Class _{Var $8___:Boolean ;}'''
expect = '''Program([ClassDecl(Id(_),Id(_),[MethodDecl(Id(k_),Instance,[param(Id(__),IntType),param(Id(V3_),IntType),param(Id(e_),BoolType),param(Id(___5ty),BoolType),param(Id(f5),BoolType),param(Id(N8Et),ClassType(Id(_K__))),param(Id(_),ClassType(Id(_K__))),param(Id(_164),ClassType(Id(_K__))),param(Id(G),ClassType(Id(_K__)))],Block([Call(NewExpr(Id(_I),[]),Id(d),[])])),AttributeDecl(Instance,ConstDecl(Id(W),ArrayType(99,ArrayType(36,ArrayType(81,ArrayType(48,ArrayType(81,IntType))))),None)),AttributeDecl(Instance,ConstDecl(Id(_),ArrayType(99,ArrayType(36,ArrayType(81,ArrayType(48,ArrayType(81,IntType))))),None)),AttributeDecl(Static,ConstDecl(Id($_i),ClassType(Id(_)),NullLiteral())),AttributeDecl(Static,ConstDecl(Id($_),ClassType(Id(_)),NullLiteral())),MethodDecl(Id(Constructor),Instance,[param(Id(_),ClassType(Id(__6)))],Block([]))]),ClassDecl(Id(_),[AttributeDecl(Static,VarDecl(Id($8___),BoolType))])])'''
self.assertTrue(TestAST.test(line, expect, 59))

def test_60(self):
line = '''Class r{}Class _:_584_6{}Class n03{}Class _{}Class h{}Class _T:j{Destructor (){}Val __330:Int ;$_E(_x1:Boolean ;U,Ijxn2,W:Boolean ;i_:String ){Return ;}Var _D:Array [String ,0500];}Class _{}'''
expect = '''Program([ClassDecl(Id(r),[]),ClassDecl(Id(_),Id(_584_6),[]),ClassDecl(Id(n03),[]),ClassDecl(Id(_),[]),ClassDecl(Id(h),[]),ClassDecl(Id(_T),Id(j),[MethodDecl(Id(Destructor),Instance,[],Block([])),AttributeDecl(Instance,ConstDecl(Id(__330),IntType,None)),MethodDecl(Id($_E),Static,[param(Id(_x1),BoolType),param(Id(U),BoolType),param(Id(Ijxn2),BoolType),param(Id(W),BoolType),param(Id(i_),StringType)],Block([Return()])),AttributeDecl(Instance,VarDecl(Id(_D),ArrayType(320,StringType)))]),ClassDecl(Id(_),[])])'''
self.assertTrue(TestAST.test(line, expect, 60))

def test_61(self):
line = '''Class _:_0{}Class _{Destructor (){}$1(_:Array [Array [Array [Array [Boolean ,045],321_0_4_98_7],3],0B10010];_6,_,_,_,_:Array [Array [Array [Array [String ,0B10010],0X39],8],01];m:Array [Array [Array [Array [Int ,0B10010],0b1010010],0b1010010],0b1]){} }'''
expect = '''Program([ClassDecl(Id(_),Id(_0),[]),ClassDecl(Id(_),[MethodDecl(Id(Destructor),Instance,[],Block([])),MethodDecl(Id($1),Static,[param(Id(_),ArrayType(18,ArrayType(3,ArrayType(32104987,ArrayType(37,BoolType))))),param(Id(_6),ArrayType(1,ArrayType(8,ArrayType(57,ArrayType(18,StringType))))),param(Id(_),ArrayType(1,ArrayType(8,ArrayType(57,ArrayType(18,StringType))))),param(Id(_),ArrayType(1,ArrayType(8,ArrayType(57,ArrayType(18,StringType))))),param(Id(_),ArrayType(1,ArrayType(8,ArrayType(57,ArrayType(18,StringType))))),param(Id(_),ArrayType(1,ArrayType(8,ArrayType(57,ArrayType(18,StringType))))),param(Id(m),ArrayType(1,ArrayType(82,ArrayType(82,ArrayType(18,IntType)))))],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 61))

def test_62(self):
line = '''Class eM:RM_{Var _,_:Array [Array [Array [Array [String ,0X39],69],06],0731];Destructor (){} }Class e:_{}Class _:_t{}Class _{}Class _m:_{Destructor (){} }Class _Q08_{Var $4s:Array [String ,0x34];}Class k:S{}'''
expect = '''Program([ClassDecl(Id(eM),Id(RM_),[AttributeDecl(Instance,VarDecl(Id(_),ArrayType(473,ArrayType(6,ArrayType(69,ArrayType(57,StringType)))))),AttributeDecl(Instance,VarDecl(Id(_),ArrayType(473,ArrayType(6,ArrayType(69,ArrayType(57,StringType)))))),MethodDecl(Id(Destructor),Instance,[],Block([]))]),ClassDecl(Id(e),Id(_),[]),ClassDecl(Id(_),Id(_t),[]),ClassDecl(Id(_),[]),ClassDecl(Id(_m),Id(_),[MethodDecl(Id(Destructor),Instance,[],Block([]))]),ClassDecl(Id(_Q08_),[AttributeDecl(Static,VarDecl(Id($4s),ArrayType(52,StringType)))]),ClassDecl(Id(k),Id(S),[])])'''
self.assertTrue(TestAST.test(line, expect, 62))

def test_63(self):
line = '''Class _{}Class _87_{Constructor (_:Array [Array [Int ,97],0XB_4_A];_:Float ;zl,Zz:Array [Boolean ,0b1_00_0];_0,u_,j5oGJ:Boolean ;__,_,P:Array [Array [Int ,97],0x18]){Continue ;Continue ;} }'''
expect = '''Program([ClassDecl(Id(_),[]),ClassDecl(Id(_87_),[MethodDecl(Id(Constructor),Instance,[param(Id(_),ArrayType(2890,ArrayType(97,IntType))),param(Id(_),FloatType),param(Id(zl),ArrayType(8,BoolType)),param(Id(Zz),ArrayType(8,BoolType)),param(Id(_0),BoolType),param(Id(u_),BoolType),param(Id(j5oGJ),BoolType),param(Id(__),ArrayType(24,ArrayType(97,IntType))),param(Id(_),ArrayType(24,ArrayType(97,IntType))),param(Id(P),ArrayType(24,ArrayType(97,IntType)))],Block([Continue,Continue]))])])'''
self.assertTrue(TestAST.test(line, expect, 63))

def test_64(self):
line = '''Class _{}Class V{Var $_,_8,f__:Array [Array [Array [String ,0X10],072],0XE];}Class _1R{Destructor (){ {}Continue ;}Var $O:Array [Array [Array [Array [Array [Int ,0b100],072],0x26],5_15_5_0_7],3_0];Val _,$0R,$P:Array [Float ,89];}'''
expect = '''Program([ClassDecl(Id(_),[]),ClassDecl(Id(V),[AttributeDecl(Static,VarDecl(Id($_),ArrayType(14,ArrayType(58,ArrayType(16,StringType))))),AttributeDecl(Instance,VarDecl(Id(_8),ArrayType(14,ArrayType(58,ArrayType(16,StringType))))),AttributeDecl(Instance,VarDecl(Id(f__),ArrayType(14,ArrayType(58,ArrayType(16,StringType)))))]),ClassDecl(Id(_1R),[MethodDecl(Id(Destructor),Instance,[],Block([Block([]),Continue])),AttributeDecl(Static,VarDecl(Id($O),ArrayType(30,ArrayType(515507,ArrayType(38,ArrayType(58,ArrayType(4,IntType))))))),AttributeDecl(Instance,ConstDecl(Id(_),ArrayType(89,FloatType),None)),AttributeDecl(Static,ConstDecl(Id($0R),ArrayType(89,FloatType),None)),AttributeDecl(Static,ConstDecl(Id($P),ArrayType(89,FloatType),None))])])'''
self.assertTrue(TestAST.test(line, expect, 64))

def test_65(self):
line = '''Class gU{Constructor (h,B__:Array [String ,0b1_1_1_00];_:Array [Array [Array [String ,035],0b1001],0b1];_:Array [String ,0x2]){}$_N(_b:Array [Array [Boolean ,2_9_4],04]){Continue ;{} }Destructor (){Break ;} }'''
expect = '''Program([ClassDecl(Id(gU),[MethodDecl(Id(Constructor),Instance,[param(Id(h),ArrayType(28,StringType)),param(Id(B__),ArrayType(28,StringType)),param(Id(_),ArrayType(1,ArrayType(9,ArrayType(29,StringType)))),param(Id(_),ArrayType(2,StringType))],Block([])),MethodDecl(Id($_N),Static,[param(Id(_b),ArrayType(4,ArrayType(294,BoolType)))],Block([Continue,Block([])])),MethodDecl(Id(Destructor),Instance,[],Block([Break]))])])'''
self.assertTrue(TestAST.test(line, expect, 65))

def test_66(self):
line = '''Class _9{$__(){}Constructor (){Var t_:Int ;Return ;}$_(_0,_:Array [Boolean ,0XA_0C1_6_4];_,_:String ;_,_M_h:Boolean ;_,kCnD63:n1n;_6,i:Float ;_,c1:Array [Int ,0132]){}$C_4(){Continue ;Continue ;} }'''
expect = '''Program([ClassDecl(Id(_9),[MethodDecl(Id($__),Static,[],Block([])),MethodDecl(Id(Constructor),Instance,[],Block([VarDecl(Id(t_),IntType),Return()])),MethodDecl(Id($_),Static,[param(Id(_0),ArrayType(10535268,BoolType)),param(Id(_),ArrayType(10535268,BoolType)),param(Id(_),StringType),param(Id(_),StringType),param(Id(_),BoolType),param(Id(_M_h),BoolType),param(Id(_),ClassType(Id(n1n))),param(Id(kCnD63),ClassType(Id(n1n))),param(Id(_6),FloatType),param(Id(i),FloatType),param(Id(_),ArrayType(90,IntType)),param(Id(c1),ArrayType(90,IntType))],Block([])),MethodDecl(Id($C_4),Static,[],Block([Continue,Continue]))])])'''
self.assertTrue(TestAST.test(line, expect, 66))

def test_67(self):
line = '''Class CO:_{$1(RIMQ,d6,__,z:ZEX){}Var $r,_:Array [Array [Array [Array [Array [Boolean ,0b1],017],0x2],0x5],0x12];Val m___5:L__W_;Var _o3:Array [Array [Int ,017],060_3];}Class _:_0_{}Class t{}Class _Ga__{}'''
expect = '''Program([ClassDecl(Id(CO),Id(_),[MethodDecl(Id($1),Static,[param(Id(RIMQ),ClassType(Id(ZEX))),param(Id(d6),ClassType(Id(ZEX))),param(Id(__),ClassType(Id(ZEX))),param(Id(z),ClassType(Id(ZEX)))],Block([])),AttributeDecl(Static,VarDecl(Id($r),ArrayType(18,ArrayType(5,ArrayType(2,ArrayType(15,ArrayType(1,BoolType))))))),AttributeDecl(Instance,VarDecl(Id(_),ArrayType(18,ArrayType(5,ArrayType(2,ArrayType(15,ArrayType(1,BoolType))))))),AttributeDecl(Instance,ConstDecl(Id(m___5),ClassType(Id(L__W_)),NullLiteral())),AttributeDecl(Instance,VarDecl(Id(_o3),ArrayType(387,ArrayType(15,IntType))))]),ClassDecl(Id(_),Id(_0_),[]),ClassDecl(Id(t),[]),ClassDecl(Id(_Ga__),[])])'''
self.assertTrue(TestAST.test(line, expect, 67))

def test_68(self):
line = '''Class F:_{}Class ___:_6{_H(x:Array [Array [Array [String ,0b110000],03],94];_:Array [Array [Array [Int ,94],0312],0x4C];y_8U,_:Int ){}Var _j,$4:_I;$C(J:_5_;X:E__;_:_){}$1(VI9,E,s,m_,___:Float ){} }'''
expect = '''Program([ClassDecl(Id(F),Id(_),[]),ClassDecl(Id(___),Id(_6),[MethodDecl(Id(_H),Instance,[param(Id(x),ArrayType(94,ArrayType(3,ArrayType(48,StringType)))),param(Id(_),ArrayType(76,ArrayType(202,ArrayType(94,IntType)))),param(Id(y_8U),IntType),param(Id(_),IntType)],Block([])),AttributeDecl(Instance,VarDecl(Id(_j),ClassType(Id(_I)),NullLiteral())),AttributeDecl(Static,VarDecl(Id($4),ClassType(Id(_I)),NullLiteral())),MethodDecl(Id($C),Static,[param(Id(J),ClassType(Id(_5_))),param(Id(X),ClassType(Id(E__))),param(Id(_),ClassType(Id(_)))],Block([])),MethodDecl(Id($1),Static,[param(Id(VI9),FloatType),param(Id(E),FloatType),param(Id(s),FloatType),param(Id(m_),FloatType),param(Id(___),FloatType)],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 68))

def test_69(self):
line = '''Class Z:Q7_4{_2_(_,__:Array [Array [Array [Array [Array [Float ,0B1],053],053],064],3];_3:Array [Array [Array [Float ,06],0b1_1],0B1001111];n:Array [Array [Array [Int ,0B1001111],05_2_3_2],0B1001111];e_,YX:Boolean ;L:Array [Array [Float ,053],053];Eo,x,b_,_,_e,i,r:__;_3:Array [Array [Float ,3],0B1001111];L__,g_10:Array [Array [Array [Array [String ,3],053],0x47],677_70]){}Constructor (_2_,n,y,_:String ){} }'''
expect = '''Program([ClassDecl(Id(Z),Id(Q7_4),[MethodDecl(Id(_2_),Instance,[param(Id(_),ArrayType(3,ArrayType(52,ArrayType(43,ArrayType(43,ArrayType(1,FloatType)))))),param(Id(__),ArrayType(3,ArrayType(52,ArrayType(43,ArrayType(43,ArrayType(1,FloatType)))))),param(Id(_3),ArrayType(79,ArrayType(3,ArrayType(6,FloatType)))),param(Id(n),ArrayType(79,ArrayType(2714,ArrayType(79,IntType)))),param(Id(e_),BoolType),param(Id(YX),BoolType),param(Id(L),ArrayType(43,ArrayType(43,FloatType))),param(Id(Eo),ClassType(Id(__))),param(Id(x),ClassType(Id(__))),param(Id(b_),ClassType(Id(__))),param(Id(_),ClassType(Id(__))),param(Id(_e),ClassType(Id(__))),param(Id(i),ClassType(Id(__))),param(Id(r),ClassType(Id(__))),param(Id(_3),ArrayType(79,ArrayType(3,FloatType))),param(Id(L__),ArrayType(67770,ArrayType(71,ArrayType(43,ArrayType(3,StringType))))),param(Id(g_10),ArrayType(67770,ArrayType(71,ArrayType(43,ArrayType(3,StringType)))))],Block([])),MethodDecl(Id(Constructor),Instance,[param(Id(_2_),StringType),param(Id(n),StringType),param(Id(y),StringType),param(Id(_),StringType)],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 69))

def test_70(self):
line = '''Class Eq:U_{Var $_Ke_99kO,$S,a,$y0m:A;Constructor (w:Array [Array [Boolean ,0B1001],0B11]){}Val f:Array [Array [Array [Boolean ,0xA],0x2],02];Destructor (){ {} }Val $_6_g:_;}'''
expect = '''Program([ClassDecl(Id(Eq),Id(U_),[AttributeDecl(Static,VarDecl(Id($_Ke_99kO),ClassType(Id(A)),NullLiteral())),AttributeDecl(Static,VarDecl(Id($S),ClassType(Id(A)),NullLiteral())),AttributeDecl(Instance,VarDecl(Id(a),ClassType(Id(A)),NullLiteral())),AttributeDecl(Static,VarDecl(Id($y0m),ClassType(Id(A)),NullLiteral())),MethodDecl(Id(Constructor),Instance,[param(Id(w),ArrayType(3,ArrayType(9,BoolType)))],Block([])),AttributeDecl(Instance,ConstDecl(Id(f),ArrayType(2,ArrayType(2,ArrayType(10,BoolType))),None)),MethodDecl(Id(Destructor),Instance,[],Block([Block([])])),AttributeDecl(Static,ConstDecl(Id($_6_g),ClassType(Id(_)),NullLiteral()))])])'''
self.assertTrue(TestAST.test(line, expect, 70))

def test_71(self):
line = '''Class O7tM_7:_B_5{Constructor (){pH3::$G1();Break ;}Val _5,$_,ta:String ;Constructor (_7_,_:k;Y,P_,j31,_:Int ;_:_){Var RZ,__:Array [Array [Array [Array [Int ,04],0X1_F_B],0114],0114];} }Class o6:__7{}Class l:_w49{}'''
expect = '''Program([ClassDecl(Id(O7tM_7),Id(_B_5),[MethodDecl(Id(Constructor),Instance,[],Block([Call(Id(pH3),Id($G1),[]),Break])),AttributeDecl(Instance,ConstDecl(Id(_5),StringType,None)),AttributeDecl(Static,ConstDecl(Id($_),StringType,None)),AttributeDecl(Instance,ConstDecl(Id(ta),StringType,None)),MethodDecl(Id(Constructor),Instance,[param(Id(_7_),ClassType(Id(k))),param(Id(_),ClassType(Id(k))),param(Id(Y),IntType),param(Id(P_),IntType),param(Id(j31),IntType),param(Id(_),IntType),param(Id(_),ClassType(Id(_)))],Block([VarDecl(Id(RZ),ArrayType(76,ArrayType(76,ArrayType(507,ArrayType(4,IntType))))),VarDecl(Id(__),ArrayType(76,ArrayType(76,ArrayType(507,ArrayType(4,IntType)))))]))]),ClassDecl(Id(o6),Id(__7),[]),ClassDecl(Id(l),Id(_w49),[])])'''
self.assertTrue(TestAST.test(line, expect, 71))

def test_72(self):
line = '''Class _:_{Constructor (){}Constructor (_:Array [Int ,3];s__,x_,d__:Array [Int ,0xE6]){Val q71_,F:Array [Boolean ,0B1_1_0_1_0];}Destructor (){}Destructor (){Continue ;} }'''
expect = '''Program([ClassDecl(Id(_),Id(_),[MethodDecl(Id(Constructor),Instance,[],Block([])),MethodDecl(Id(Constructor),Instance,[param(Id(_),ArrayType(3,IntType)),param(Id(s__),ArrayType(230,IntType)),param(Id(x_),ArrayType(230,IntType)),param(Id(d__),ArrayType(230,IntType))],Block([ConstDecl(Id(q71_),ArrayType(26,BoolType),None),ConstDecl(Id(F),ArrayType(26,BoolType),None)])),MethodDecl(Id(Destructor),Instance,[],Block([])),MethodDecl(Id(Destructor),Instance,[],Block([Continue]))])])'''
self.assertTrue(TestAST.test(line, expect, 72))

def test_73(self):
line = '''Class A:kB{}Class _{Var iLw:j8l5;Var $3,$_,_:Array [Int ,0b110];}Class _:_3{}Class _9f3:b0Th{___(_:Float ){} }Class f{}Class F6{}Class _Sx:Ig9fG{}Class j{Constructor (){} }'''
expect = '''Program([ClassDecl(Id(A),Id(kB),[]),ClassDecl(Id(_),[AttributeDecl(Instance,VarDecl(Id(iLw),ClassType(Id(j8l5)),NullLiteral())),AttributeDecl(Static,VarDecl(Id($3),ArrayType(6,IntType))),AttributeDecl(Static,VarDecl(Id($_),ArrayType(6,IntType))),AttributeDecl(Instance,VarDecl(Id(_),ArrayType(6,IntType)))]),ClassDecl(Id(_),Id(_3),[]),ClassDecl(Id(_9f3),Id(b0Th),[MethodDecl(Id(___),Instance,[param(Id(_),FloatType)],Block([]))]),ClassDecl(Id(f),[]),ClassDecl(Id(F6),[]),ClassDecl(Id(_Sx),Id(Ig9fG),[]),ClassDecl(Id(j),[MethodDecl(Id(Constructor),Instance,[],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 73))

def test_74(self):
line = '''Class _:t{_(Z5:String ;s1,__:k14769;U,T:Array [String ,07];i,Q:Array [Array [Array [Array [Array [Array [Array [Float ,0131],02_2],0131],0X9_2],0131],0131],0B100010];_,_,_:Array [String ,0X8_C6]){}Constructor (){} }Class __:E29{}'''
expect = '''Program([ClassDecl(Id(_),Id(t),[MethodDecl(Id(_),Instance,[param(Id(Z5),StringType),param(Id(s1),ClassType(Id(k14769))),param(Id(__),ClassType(Id(k14769))),param(Id(U),ArrayType(7,StringType)),param(Id(T),ArrayType(7,StringType)),param(Id(i),ArrayType(34,ArrayType(89,ArrayType(89,ArrayType(146,ArrayType(89,ArrayType(18,ArrayType(89,FloatType)))))))),param(Id(Q),ArrayType(34,ArrayType(89,ArrayType(89,ArrayType(146,ArrayType(89,ArrayType(18,ArrayType(89,FloatType)))))))),param(Id(_),ArrayType(2246,StringType)),param(Id(_),ArrayType(2246,StringType)),param(Id(_),ArrayType(2246,StringType))],Block([])),MethodDecl(Id(Constructor),Instance,[],Block([]))]),ClassDecl(Id(__),Id(E29),[])])'''
self.assertTrue(TestAST.test(line, expect, 74))

def test_75(self):
line = '''Class __:_0_{Constructor (__O,Sq,Q,_k:Array [Array [Float ,0b11001],0xB];o,_w:Array [Array [Array [String ,13],5],0135];_:_;e,A:Array [Array [Array [String ,03_0],0B111],0X4]){A::$E();} }'''
expect = '''Program([ClassDecl(Id(__),Id(_0_),[MethodDecl(Id(Constructor),Instance,[param(Id(__O),ArrayType(11,ArrayType(25,FloatType))),param(Id(Sq),ArrayType(11,ArrayType(25,FloatType))),param(Id(Q),ArrayType(11,ArrayType(25,FloatType))),param(Id(_k),ArrayType(11,ArrayType(25,FloatType))),param(Id(o),ArrayType(93,ArrayType(5,ArrayType(13,StringType)))),param(Id(_w),ArrayType(93,ArrayType(5,ArrayType(13,StringType)))),param(Id(_),ClassType(Id(_))),param(Id(e),ArrayType(4,ArrayType(7,ArrayType(24,StringType)))),param(Id(A),ArrayType(4,ArrayType(7,ArrayType(24,StringType))))],Block([Call(Id(A),Id($E),[])]))])])'''
self.assertTrue(TestAST.test(line, expect, 75))

def test_76(self):
line = '''Class _{}Class y:_{Destructor (){}Constructor (_:_T;_R4:Array [Array [Boolean ,4_5_053],0B110]){ {_::$h8._();{} }}Val Z,r,A5a,$W_x:Boolean ;}Class q0:O{_9(){Continue ;} }Class c_{}'''
expect = '''Program([ClassDecl(Id(_),[]),ClassDecl(Id(y),Id(_),[MethodDecl(Id(Destructor),Instance,[],Block([])),MethodDecl(Id(Constructor),Instance,[param(Id(_),ClassType(Id(_T))),param(Id(_R4),ArrayType(6,ArrayType(45053,BoolType)))],Block([Block([Call(FieldAccess(Id(_),Id($h8)),Id(_),[]),Block([])])])),AttributeDecl(Instance,ConstDecl(Id(Z),BoolType,None)),AttributeDecl(Instance,ConstDecl(Id(r),BoolType,None)),AttributeDecl(Instance,ConstDecl(Id(A5a),BoolType,None)),AttributeDecl(Static,ConstDecl(Id($W_x),BoolType,None))]),ClassDecl(Id(q0),Id(O),[MethodDecl(Id(_9),Instance,[],Block([Continue]))]),ClassDecl(Id(c_),[])])'''
self.assertTrue(TestAST.test(line, expect, 76))

def test_77(self):
line = '''Class M6_:_{Constructor (_2,_,m:Array [Array [Array [Array [Int ,0B1001000],01],0x54],0B1001000];_6:Int ;_:Array [Array [Boolean ,0b1000111],0xE];_:_8Q_3){Break ;}Destructor (){f_74_::$_1();Var S:__9_;} }'''
expect = '''Program([ClassDecl(Id(M6_),Id(_),[MethodDecl(Id(Constructor),Instance,[param(Id(_2),ArrayType(72,ArrayType(84,ArrayType(1,ArrayType(72,IntType))))),param(Id(_),ArrayType(72,ArrayType(84,ArrayType(1,ArrayType(72,IntType))))),param(Id(m),ArrayType(72,ArrayType(84,ArrayType(1,ArrayType(72,IntType))))),param(Id(_6),IntType),param(Id(_),ArrayType(14,ArrayType(71,BoolType))),param(Id(_),ClassType(Id(_8Q_3)))],Block([Break])),MethodDecl(Id(Destructor),Instance,[],Block([Call(Id(f_74_),Id($_1),[]),VarDecl(Id(S),ClassType(Id(__9_)),NullLiteral())]))])])'''
self.assertTrue(TestAST.test(line, expect, 77))

def test_78(self):
line = '''Class U_9:Y_1_{Constructor (o_E,n,_4:Array [Array [Array [Array [String ,0xA],0b1011000],06],0b1011000];_o:Array [Array [Array [Array [Array [Array [Int ,49],0XB],017_5_4],06],0b1],0X1];_m1:_;hT,_7dhR:Boolean ;_:Array [Array [Float ,0B1],0xF_D_DA];__o8Sp,_2_x56_:_;y:Array [Float ,012_3];_:Array [Float ,6]){} }Class B:nO{}Class x_5:a_4_9{}Class k:_{Constructor (B,H:q){} }'''
expect = '''Program([ClassDecl(Id(U_9),Id(Y_1_),[MethodDecl(Id(Constructor),Instance,[param(Id(o_E),ArrayType(88,ArrayType(6,ArrayType(88,ArrayType(10,StringType))))),param(Id(n),ArrayType(88,ArrayType(6,ArrayType(88,ArrayType(10,StringType))))),param(Id(_4),ArrayType(88,ArrayType(6,ArrayType(88,ArrayType(10,StringType))))),param(Id(_o),ArrayType(1,ArrayType(1,ArrayType(6,ArrayType(1004,ArrayType(11,ArrayType(49,IntType))))))),param(Id(_m1),ClassType(Id(_))),param(Id(hT),BoolType),param(Id(_7dhR),BoolType),param(Id(_),ArrayType(64986,ArrayType(1,FloatType))),param(Id(__o8Sp),ClassType(Id(_))),param(Id(_2_x56_),ClassType(Id(_))),param(Id(y),ArrayType(83,FloatType)),param(Id(_),ArrayType(6,FloatType))],Block([]))]),ClassDecl(Id(B),Id(nO),[]),ClassDecl(Id(x_5),Id(a_4_9),[]),ClassDecl(Id(k),Id(_),[MethodDecl(Id(Constructor),Instance,[param(Id(B),ClassType(Id(q))),param(Id(H),ClassType(Id(q)))],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 78))

def test_79(self):
line = '''Class _:_{Constructor (__y_y_,Z:t6;_,F:k;_57:String ;_:Array [Array [Array [Int ,0x27],1],0X26];y:Int ){} }Class H:m{Var _:Array [Boolean ,1_04];}Class _c_{Destructor (){} }Class _9:_39{}'''
expect = '''Program([ClassDecl(Id(_),Id(_),[MethodDecl(Id(Constructor),Instance,[param(Id(__y_y_),ClassType(Id(t6))),param(Id(Z),ClassType(Id(t6))),param(Id(_),ClassType(Id(k))),param(Id(F),ClassType(Id(k))),param(Id(_57),StringType),param(Id(_),ArrayType(38,ArrayType(1,ArrayType(39,IntType)))),param(Id(y),IntType)],Block([]))]),ClassDecl(Id(H),Id(m),[AttributeDecl(Instance,VarDecl(Id(_),ArrayType(104,BoolType)))]),ClassDecl(Id(_c_),[MethodDecl(Id(Destructor),Instance,[],Block([]))]),ClassDecl(Id(_9),Id(_39),[])])'''
self.assertTrue(TestAST.test(line, expect, 79))

def test_80(self):
line = '''Class _{Val cS:String ;Var $__2,_:Array [Int ,014];}Class _{__(P:Array [Boolean ,014]){}Destructor (){}Var D_:Float ;Val $_,h,__81,__79__,$I:Array [String ,0x31];}Class lx:_V9{Destructor (){} }'''
expect = '''Program([ClassDecl(Id(_),[AttributeDecl(Instance,ConstDecl(Id(cS),StringType,None)),AttributeDecl(Static,VarDecl(Id($__2),ArrayType(12,IntType))),AttributeDecl(Instance,VarDecl(Id(_),ArrayType(12,IntType)))]),ClassDecl(Id(_),[MethodDecl(Id(__),Instance,[param(Id(P),ArrayType(12,BoolType))],Block([])),MethodDecl(Id(Destructor),Instance,[],Block([])),AttributeDecl(Instance,VarDecl(Id(D_),FloatType)),AttributeDecl(Static,ConstDecl(Id($_),ArrayType(49,StringType),None)),AttributeDecl(Instance,ConstDecl(Id(h),ArrayType(49,StringType),None)),AttributeDecl(Instance,ConstDecl(Id(__81),ArrayType(49,StringType),None)),AttributeDecl(Instance,ConstDecl(Id(__79__),ArrayType(49,StringType),None)),AttributeDecl(Static,ConstDecl(Id($I),ArrayType(49,StringType),None))]),ClassDecl(Id(lx),Id(_V9),[MethodDecl(Id(Destructor),Instance,[],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 80))

def test_81(self):
line = '''Class L:_{$Zsy__58e(){}Constructor (){Return ;Val _0:Int ;}$_Ny(k,__ErT,_:m){}Val y,I,_8VN:String ;Val Sj:Array [String ,1];}Class _:_1{Destructor (){}Var W:lpvl_90__;}Class oEd{}'''
expect = '''Program([ClassDecl(Id(L),Id(_),[MethodDecl(Id($Zsy__58e),Static,[],Block([])),MethodDecl(Id(Constructor),Instance,[],Block([Return(),ConstDecl(Id(_0),IntType,None)])),MethodDecl(Id($_Ny),Static,[param(Id(k),ClassType(Id(m))),param(Id(__ErT),ClassType(Id(m))),param(Id(_),ClassType(Id(m)))],Block([])),AttributeDecl(Instance,ConstDecl(Id(y),StringType,None)),AttributeDecl(Instance,ConstDecl(Id(I),StringType,None)),AttributeDecl(Instance,ConstDecl(Id(_8VN),StringType,None)),AttributeDecl(Instance,ConstDecl(Id(Sj),ArrayType(1,StringType),None))]),ClassDecl(Id(_),Id(_1),[MethodDecl(Id(Destructor),Instance,[],Block([])),AttributeDecl(Instance,VarDecl(Id(W),ClassType(Id(lpvl_90__)),NullLiteral()))]),ClassDecl(Id(oEd),[])])'''
self.assertTrue(TestAST.test(line, expect, 81))

def test_82(self):
line = '''Class N{Destructor (){Break ;{_::$3();}Continue ;} }Class _{}Class jT0:_{Constructor (ug7,_:Int ;BK03ZK:Array [Array [Array [Array [Array [Array [Array [Float ,8],26],0B1000011],0x27],0x27],3_92],0B1000011]){} }Class S{}Class G{Destructor (){Continue ;} }Class r:h{}Class Z_d__{}'''
expect = '''Program([ClassDecl(Id(N),[MethodDecl(Id(Destructor),Instance,[],Block([Break,Block([Call(Id(_),Id($3),[])]),Continue]))]),ClassDecl(Id(_),[]),ClassDecl(Id(jT0),Id(_),[MethodDecl(Id(Constructor),Instance,[param(Id(ug7),IntType),param(Id(_),IntType),param(Id(BK03ZK),ArrayType(67,ArrayType(392,ArrayType(39,ArrayType(39,ArrayType(67,ArrayType(26,ArrayType(8,FloatType))))))))],Block([]))]),ClassDecl(Id(S),[]),ClassDecl(Id(G),[MethodDecl(Id(Destructor),Instance,[],Block([Continue]))]),ClassDecl(Id(r),Id(h),[]),ClassDecl(Id(Z_d__),[])])'''
self.assertTrue(TestAST.test(line, expect, 82))

def test_83(self):
line = '''Class __{_(d:__;l,__:Array [Boolean ,02_4_7_5]){}_(){}pW(){} }Class m3:_d{Val $_,$01,__8:Boolean ;Constructor (S:_;l:N;_M2H__B:Array [Array [Float ,0x35],0XF]){Break ;}Var w7f_4_,$4,U:Array [Array [Array [Boolean ,7],0XB],2_8];Constructor (){} }'''
expect = '''Program([ClassDecl(Id(__),[MethodDecl(Id(_),Instance,[param(Id(d),ClassType(Id(__))),param(Id(l),ArrayType(1341,BoolType)),param(Id(__),ArrayType(1341,BoolType))],Block([])),MethodDecl(Id(_),Instance,[],Block([])),MethodDecl(Id(pW),Instance,[],Block([]))]),ClassDecl(Id(m3),Id(_d),[AttributeDecl(Static,ConstDecl(Id($_),BoolType,None)),AttributeDecl(Static,ConstDecl(Id($01),BoolType,None)),AttributeDecl(Instance,ConstDecl(Id(__8),BoolType,None)),MethodDecl(Id(Constructor),Instance,[param(Id(S),ClassType(Id(_))),param(Id(l),ClassType(Id(N))),param(Id(_M2H__B),ArrayType(15,ArrayType(53,FloatType)))],Block([Break])),AttributeDecl(Instance,VarDecl(Id(w7f_4_),ArrayType(28,ArrayType(11,ArrayType(7,BoolType))))),AttributeDecl(Static,VarDecl(Id($4),ArrayType(28,ArrayType(11,ArrayType(7,BoolType))))),AttributeDecl(Instance,VarDecl(Id(U),ArrayType(28,ArrayType(11,ArrayType(7,BoolType))))),MethodDecl(Id(Constructor),Instance,[],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 83))

def test_84(self):
line = '''Class _:_{Var $3,q,$_,$2m,_,$G1,xRb,$Z:Array [String ,0x8];}Class _8{pI(I4:__;_:Float ){}Var $_:Float ;Constructor (_N,_:Array [Array [Int ,0x3],82];_:String ;_,u32:tr_){} }'''
expect = '''Program([ClassDecl(Id(_),Id(_),[AttributeDecl(Static,VarDecl(Id($3),ArrayType(8,StringType))),AttributeDecl(Instance,VarDecl(Id(q),ArrayType(8,StringType))),AttributeDecl(Static,VarDecl(Id($_),ArrayType(8,StringType))),AttributeDecl(Static,VarDecl(Id($2m),ArrayType(8,StringType))),AttributeDecl(Instance,VarDecl(Id(_),ArrayType(8,StringType))),AttributeDecl(Static,VarDecl(Id($G1),ArrayType(8,StringType))),AttributeDecl(Instance,VarDecl(Id(xRb),ArrayType(8,StringType))),AttributeDecl(Static,VarDecl(Id($Z),ArrayType(8,StringType)))]),ClassDecl(Id(_8),[MethodDecl(Id(pI),Instance,[param(Id(I4),ClassType(Id(__))),param(Id(_),FloatType)],Block([])),AttributeDecl(Static,VarDecl(Id($_),FloatType)),MethodDecl(Id(Constructor),Instance,[param(Id(_N),ArrayType(82,ArrayType(3,IntType))),param(Id(_),ArrayType(82,ArrayType(3,IntType))),param(Id(_),StringType),param(Id(_),ClassType(Id(tr_))),param(Id(u32),ClassType(Id(tr_)))],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 84))

def test_85(self):
line = '''Class G:_{__(_,_U_,_:_){}Constructor (r_,_Yt:String ;feR,s,C:Array [Float ,0B1_0]){} }Class e{}Class k405{Var a:Array [Float ,0B1011011];Var ___q_s:Array [Array [Array [Array [Array [Int ,0b1000010],0B1011011],0X4],0b1000010],65];}'''
expect = '''Program([ClassDecl(Id(G),Id(_),[MethodDecl(Id(__),Instance,[param(Id(_),ClassType(Id(_))),param(Id(_U_),ClassType(Id(_))),param(Id(_),ClassType(Id(_)))],Block([])),MethodDecl(Id(Constructor),Instance,[param(Id(r_),StringType),param(Id(_Yt),StringType),param(Id(feR),ArrayType(2,FloatType)),param(Id(s),ArrayType(2,FloatType)),param(Id(C),ArrayType(2,FloatType))],Block([]))]),ClassDecl(Id(e),[]),ClassDecl(Id(k405),[AttributeDecl(Instance,VarDecl(Id(a),ArrayType(91,FloatType))),AttributeDecl(Instance,VarDecl(Id(___q_s),ArrayType(65,ArrayType(66,ArrayType(4,ArrayType(91,ArrayType(66,IntType)))))))])])'''
self.assertTrue(TestAST.test(line, expect, 85))

def test_86(self):
line = '''Class _:F9{Destructor (){} }Class _:M__7{Constructor (_2_wV:v5j505L2;_:Float ;__,_a4_e,T3_3:Int ;_j,gT:Array [String ,0x6];W,y,_:Array [Array [Boolean ,0x13],0B1011111];a,m__:Array [Array [Array [String ,066],7],0B1_001];_,Ob:Float ;a6n:Array [Int ,0XC_0]){}Constructor (){} }'''
expect = '''Program([ClassDecl(Id(_),Id(F9),[MethodDecl(Id(Destructor),Instance,[],Block([]))]),ClassDecl(Id(_),Id(M__7),[MethodDecl(Id(Constructor),Instance,[param(Id(_2_wV),ClassType(Id(v5j505L2))),param(Id(_),FloatType),param(Id(__),IntType),param(Id(_a4_e),IntType),param(Id(T3_3),IntType),param(Id(_j),ArrayType(6,StringType)),param(Id(gT),ArrayType(6,StringType)),param(Id(W),ArrayType(95,ArrayType(19,BoolType))),param(Id(y),ArrayType(95,ArrayType(19,BoolType))),param(Id(_),ArrayType(95,ArrayType(19,BoolType))),param(Id(a),ArrayType(9,ArrayType(7,ArrayType(54,StringType)))),param(Id(m__),ArrayType(9,ArrayType(7,ArrayType(54,StringType)))),param(Id(_),FloatType),param(Id(Ob),FloatType),param(Id(a6n),ArrayType(192,IntType))],Block([])),MethodDecl(Id(Constructor),Instance,[],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 86))

def test_87(self):
line = '''Class _0:c184__f_{}Class U:e{$T(){} }Class _3{Var $8,$h,uN4:___7;$7(k_U2_:Int ;n6_x,p,wb:_;_,P:Boolean ){}Var _:Array [Array [Array [Array [String ,0X6],6],04],0XD];}'''
expect = '''Program([ClassDecl(Id(_0),Id(c184__f_),[]),ClassDecl(Id(U),Id(e),[MethodDecl(Id($T),Static,[],Block([]))]),ClassDecl(Id(_3),[AttributeDecl(Static,VarDecl(Id($8),ClassType(Id(___7)),NullLiteral())),AttributeDecl(Static,VarDecl(Id($h),ClassType(Id(___7)),NullLiteral())),AttributeDecl(Instance,VarDecl(Id(uN4),ClassType(Id(___7)),NullLiteral())),MethodDecl(Id($7),Static,[param(Id(k_U2_),IntType),param(Id(n6_x),ClassType(Id(_))),param(Id(p),ClassType(Id(_))),param(Id(wb),ClassType(Id(_))),param(Id(_),BoolType),param(Id(P),BoolType)],Block([])),AttributeDecl(Instance,VarDecl(Id(_),ArrayType(13,ArrayType(4,ArrayType(6,ArrayType(6,StringType))))))])])'''
self.assertTrue(TestAST.test(line, expect, 87))

def test_88(self):
line = '''Class Z{Destructor (){} }Class _:A{Val _:H__mIN;Var $l:Int ;}Class t_{Destructor (){} }Class f_89{Var $1P:NjPo6U;Val $9:Array [Int ,04_5];Constructor (){Val _,R:_F__;} }Class C{Constructor (_2:B_72__){} }Class _{}'''
expect = '''Program([ClassDecl(Id(Z),[MethodDecl(Id(Destructor),Instance,[],Block([]))]),ClassDecl(Id(_),Id(A),[AttributeDecl(Instance,ConstDecl(Id(_),ClassType(Id(H__mIN)),NullLiteral())),AttributeDecl(Static,VarDecl(Id($l),IntType))]),ClassDecl(Id(t_),[MethodDecl(Id(Destructor),Instance,[],Block([]))]),ClassDecl(Id(f_89),[AttributeDecl(Static,VarDecl(Id($1P),ClassType(Id(NjPo6U)),NullLiteral())),AttributeDecl(Static,ConstDecl(Id($9),ArrayType(37,IntType),None)),MethodDecl(Id(Constructor),Instance,[],Block([ConstDecl(Id(_),ClassType(Id(_F__)),NullLiteral()),ConstDecl(Id(R),ClassType(Id(_F__)),NullLiteral())]))]),ClassDecl(Id(C),[MethodDecl(Id(Constructor),Instance,[param(Id(_2),ClassType(Id(B_72__)))],Block([]))]),ClassDecl(Id(_),[])])'''
self.assertTrue(TestAST.test(line, expect, 88))

def test_89(self):
line = '''Class DB:_{Var a,_X:g;Var $7I:Int ;}Class _Yb_d5{$4(_5:String ;_:Array [Float ,040];f4,_,_:Boolean ){}Val __9f6,$b,_,u:Array [Int ,0x1271];Constructor (__2uM,DA:a;_,N:Boolean ){Return ;Var _:Array [String ,0xC];}$2(){} }'''
expect = '''Program([ClassDecl(Id(DB),Id(_),[AttributeDecl(Instance,VarDecl(Id(a),ClassType(Id(g)),NullLiteral())),AttributeDecl(Instance,VarDecl(Id(_X),ClassType(Id(g)),NullLiteral())),AttributeDecl(Static,VarDecl(Id($7I),IntType))]),ClassDecl(Id(_Yb_d5),[MethodDecl(Id($4),Static,[param(Id(_5),StringType),param(Id(_),ArrayType(32,FloatType)),param(Id(f4),BoolType),param(Id(_),BoolType),param(Id(_),BoolType)],Block([])),AttributeDecl(Instance,ConstDecl(Id(__9f6),ArrayType(4721,IntType),None)),AttributeDecl(Static,ConstDecl(Id($b),ArrayType(4721,IntType),None)),AttributeDecl(Instance,ConstDecl(Id(_),ArrayType(4721,IntType),None)),AttributeDecl(Instance,ConstDecl(Id(u),ArrayType(4721,IntType),None)),MethodDecl(Id(Constructor),Instance,[param(Id(__2uM),ClassType(Id(a))),param(Id(DA),ClassType(Id(a))),param(Id(_),BoolType),param(Id(N),BoolType)],Block([Return(),VarDecl(Id(_),ArrayType(12,StringType))])),MethodDecl(Id($2),Static,[],Block([]))])])'''
self.assertTrue(TestAST.test(line, expect, 89))

def test_90(self):
line = '''Class k{Constructor (Y7,_,_____,_,_,G_,o__,s7v:Array [Int ,0x3F];_ovW:Array [Array [Array [Array [Float ,0X45],0X45],04_3_4],5];D,K_:_;__:Int ){}Var $tm:Array [Boolean ,0x3F];Var $8,_G,u,$__:Array [Array [Array [Float ,0111],37_0],16];}Class u{}'''
expect = '''Program([ClassDecl(Id(k),[MethodDecl(Id(Constructor),Instance,[param(Id(Y7),ArrayType(63,IntType)),param(Id(_),ArrayType(63,IntType)),param(Id(_____),ArrayType(63,IntType)),param(Id(_),ArrayType(63,IntType)),param(Id(_),ArrayType(63,IntType)),param(Id(G_),ArrayType(63,IntType)),param(Id(o__),ArrayType(63,IntType)),param(Id(s7v),ArrayType(63,IntType)),param(Id(_ovW),ArrayType(5,ArrayType(284,ArrayType(69,ArrayType(69,FloatType))))),param(Id(D),ClassType(Id(_))),param(Id(K_),ClassType(Id(_))),param(Id(__),IntType)],Block([])),AttributeDecl(Static,VarDecl(Id($tm),ArrayType(63,BoolType))),AttributeDecl(Static,VarDecl(Id($8),ArrayType(16,ArrayType(370,ArrayType(73,FloatType))))),AttributeDecl(Instance,VarDecl(Id(_G),ArrayType(16,ArrayType(370,ArrayType(73,FloatType))))),AttributeDecl(Instance,VarDecl(Id(u),ArrayType(16,ArrayType(370,ArrayType(73,FloatType))))),AttributeDecl(Static,VarDecl(Id($__),ArrayType(16,ArrayType(370,ArrayType(73,FloatType)))))]),ClassDecl(Id(u),[])])'''
self.assertTrue(TestAST.test(line, expect, 90))

def test_91(self):
line = '''Class oj___x{Var IMB:Int ;Var $9,$ct,$q:_2;}Class _:_7Z{Var __,d_:Array [Float ,0x31];fT04(_9:m;o:Array [Array [String ,0B100101],062]){}Constructor (){}Val _:Array [Boolean ,0B11];Val J_,u:Array [Array [Int ,0X4],3];}'''
expect = '''Program([ClassDecl(Id(oj___x),[AttributeDecl(Instance,VarDecl(Id(IMB),IntType)