菜鸟求助，帮忙修改一段代码

cyxin

本人以前没接触过flascc，纯粹的外行一个，求大神帮我把这段反编译的代码改写成c语言版，或者指点计算过程
小弟在此表示万分感谢

1. public function GetToken(param1 : String) : String{
   
2.         var _loc5_ :  *  = 0;
   
3.         var _loc15_ :  *  = 0;
   
4.         var _loc6_ :  *  = 0;
   
5.         var _loc7_ : int = 0;
   
6.         var _loc4_ : int = 0;
   
7.         var _loc31_ :  *  = 0;
   
8.         var _loc30_ :  *  = 0;
   
9.         var _loc29_ :  *  = 0;
   
10.         var _loc28_ :  *  = 0;
    
11.         var _loc27_ :  *  = 0;
    
12.         var _loc26_ :  *  = 0;
    
13.         var _loc25_ :  *  = 0;
    
14.         var _loc24_ :  *  = 0;
    
15.         var _loc11_ :  *  = 0;
    
16.         var _loc20_ :  *  = 0;
    
17.         var _loc21_ :  *  = 0;
    
18.         var _loc22_ :  *  = 0;
    
19.         var _loc23_ :  *  = 0;
    
20.         var _loc16_ :  *  = 0;
    
21.         var _loc17_ :  *  = 0;
    
22.         var _loc18_ :  *  = 0;
    
23.         var _loc19_ :  *  = 0;
    
24.         var _loc14_ :  *  = 0;
    
25.         var _loc12_ :  *  = 0;
    
26.         var _loc10_ :  *  = 0;
    
27.         var _loc8_ :  *  = 0;
    
28.         var _loc9_ : int = 0;
    
29.         var _loc3_ :  *  = int(ESP);
    
30.         _loc5_ = _loc3_;
    
31.         _loc3_ = int(_loc3_ - 176);
    
32.         ESP = _loc3_ & -16;
    
33.         _loc15_ = int(CModule.mallocString(param1));
    
34.         _loc31_ = si8(li8(_key1));
    
35.         _loc30_ = si8(li8(_key2));
    
36.         _loc29_ = si8(li8(_key3));
    
37.         _loc28_ = si8(li8(_key4));
    
38.         _loc27_ = si8(li8(_key5));
    
39.         _loc26_ = si8(li8(_key6));
    
40.         _loc25_ = si8(li8(_key7));
    
41.         _loc24_ = si8(li8(_key8));
    
42.         _loc11_ = si8(li8(_key9));
    
43.         _loc20_ = si8(li8(_key10));
    
44.         _loc21_ = si8(li8(_key11));
    
45.         _loc22_ = si8(li8(_key12));
    
46.         _loc23_ = si8(li8(_key13));
    
47.         _loc16_ = si8(li8(_key14));
    
48.         _loc17_ = si8(li8(_key15));
    
49.         _loc18_ = si8(li8(_key16));
    
50.         _loc19_ = si8(li8(_key17));
    
51.         _loc14_ = si8(li8(_key18));
    
52.         _loc12_ = si8(li8(_key19));
    
53.         _loc10_ = si8(li8(_key20));
    
54.         _loc8_ = si8(li8(_key21));
    
55.         _loc3_ = int(_loc3_ - 96);
    
56.         si32(_loc8_, _loc3_ + 92);
    
57.         si32(_loc10_, _loc3_ + 88);
    
58.         si32(_loc12_, _loc3_ + 84);
    
59.         si32(_loc14_, _loc3_ + 80);
    
60.         si32(_loc19_, _loc3_ + 76);
    
61.         si32(_loc18_, _loc3_ + 72);
    
62.         si32(_loc17_, _loc3_ + 68);
    
63.         si32(_loc16_, _loc3_ + 64);
    
64.         si32(_loc23_, _loc3_ + 60);
    
65.         si32(_loc22_, _loc3_ + 56);
    
66.         si32(_loc21_, _loc3_ + 52);
    
67.         si32(_loc20_, _loc3_ + 48);
    
68.         si32(_loc15_, _loc3_ + 44);
    
69.         si32(_loc11_, _loc3_ + 40);
    
70.         si32(_loc24_, _loc3_ + 36);
    
71.         si32(_loc25_, _loc3_ + 32);
    
72.         si32(_loc26_, _loc3_ + 28);
    
73.         si32(_loc27_, _loc3_ + 24);
    
74.         si32(_loc28_, _loc3_ + 20);
    
75.         si32(_loc29_, _loc3_ + 16);
    
76.         si32(_loc30_, _loc3_ + 12);
    
77.         si32(_loc31_, _loc3_ + 8);
    
78.         si32(L__2E_str3, _loc3_ + 4);
    
79.         _loc9_ = _loc5_ - 128;
    
80.         si32(_loc9_, _loc3_);
    
81.         ESP = _loc3_;
    
82.         F_sprintf();
    
83.         _loc3_ = int(_loc3_ + 96);
    
84.         if (_loc15_ != 0) {
    
85.                 _loc3_ = int(_loc3_ - 16);
    
86.                 si32(_loc15_, _loc3_);
    
87.                 ESP = _loc3_;
    
88.                 F_idalloc();
    
89.                 _loc3_ = int(_loc3_ + 16);
    
90.         }
    
91.         _loc6_ = _loc9_ & -4;
    
92.         _loc30_ = li32(_loc6_);
    
93.         _loc8_ = int(_loc30_ + -16843009);
    
94.         _loc30_ = _loc30_ & -2139062144;
    
95.         _loc30_ = _loc30_^-2139062144;
    
96.         _loc8_ = _loc30_ & _loc8_;
    
97.         if (_loc8_ != 0) {
    
98.                 _loc7_ = _loc6_ + 4;
    
99.                 _loc15_ = 0;
    
100.                 while (true) {
     
101.                         _loc4_ = _loc9_ + _loc15_;
     
102.                         if (uint(_loc4_) < uint(_loc7_)) {
     
103.                                 _loc8_ = li8(_loc4_);
     
104.                                 if (_loc8_ != 0) {
     
105.                                         _loc15_ = int(_loc15_ + 1);
     
106.                                         continue;
     
107.                                 }
     
108.                                 break;
     
109.                         }
     
110.                 }
     
111.                 _loc3_ = int(_loc3_ - 16);
     
112.                 si32(_loc15_, _loc3_ + 4);
     
113.                 si32(_loc9_, _loc3_);
     
114.                 _loc9_ = _loc5_ - 161;
     
115.                 si32(_loc9_, _loc3_ + 8);
     
116.                 ESP = _loc3_;
     
117.                 F_generate_md5();
     
118.                 _loc3_ = int(_loc3_ + 16);
     
119.                 _loc6_ = _loc9_ & -4;
     
120.                 _loc30_ = li32(_loc6_);
     
121.                 _loc8_ = int(_loc30_ + -16843009);
     
122.                 _loc30_ = _loc30_ & -2139062144;
     
123.                 _loc30_ = _loc30_^-2139062144;
     
124.                 _loc8_ = _loc30_ & _loc8_;
     
125.                 if (_loc8_ != 0) {
     
126.                         _loc7_ = _loc6_ + 4;
     
127.                         _loc15_ = 0;
     
128.                         while (true) {
     
129.                                 _loc4_ = _loc9_ + _loc15_;
     
130.                                 if (uint(_loc4_) < uint(_loc7_)) {
     
131.                                         _loc8_ = li8(_loc4_);
     
132.                                         if (_loc8_ != 0) {
     
133.                                                 _loc15_ = int(_loc15_ + 1);
     
134.                                                 continue;
     
135.                                         }
     
136.                                         break;
     
137.                                 }
     
138.                         }
     
139.                         var _loc2_ : String = CModule.readString(_loc9_, _loc15_);
     
140.                         var _loc13_ :  *  = _loc2_;
     
141.                         _loc3_ = _loc5_;
     
142.                         ESP = _loc3_;
     
143.                         return _loc13_;
     
144.                 }
     
145.                 _loc15_ = int(_loc6_ + 4);
     
146.                 while (true) {
     
147.                         _loc6_ = li32(_loc15_);
     
148.                         _loc8_ = int(_loc6_ + -16843009);
     
149.                         _loc30_ = _loc6_ & -2139062144;
     
150.                         _loc30_ = _loc30_^-2139062144;
     
151.                         _loc8_ = _loc30_ & _loc8_;
     
152.                         if (_loc8_ != 0) {
     
153.                                 _loc8_ = _loc6_ & 255;
     
154.                                 if (_loc8_ == 0) {
     
155.                                         _loc15_ = int(_loc15_ - _loc9_);
     
156.                                 } else {
     
157.                                         _loc8_ = li8(_loc15_ + 1);
     
158.                                         if (_loc8_ == 0) {
     
159.                                                 _loc8_ = int(1 - _loc9_);
     
160.                                                 _loc15_ = int(_loc8_ + _loc15_);
     
161.                                         } else {
     
162.                                                 _loc8_ = li8(_loc15_ + 2);
     
163.                                                 if (_loc8_ == 0) {
     
164.                                                         _loc8_ = int(2 - _loc9_);
     
165.                                                         _loc15_ = int(_loc8_ + _loc15_);
     
166.                                                 } else {
     
167.                                                         _loc8_ = li8(_loc15_ + 3);
     
168.                                                         if (_loc8_ == 0) {
     
169.                                                                 _loc8_ = int(3 - _loc9_);
     
170.                                                                 _loc15_ = int(_loc8_ + _loc15_);
     
171.                                                         } else {
     
172.                                                                 continue;
     
173.                                                         }
     
174.                                                 }
     
175.                                         }
     
176.                                 }
     
177.                                 §§goto(addr711);
     
178.                         }
     
179.                 }
     
180.         }
     
181.         _loc6_ = int(_loc6_ + 4);
     
182.         while (true) {
     
183.                 _loc15_ = li32(_loc6_);
     
184.                 _loc8_ = int(_loc15_ + -16843009);
     
185.                 _loc30_ = _loc15_ & -2139062144;
     
186.                 _loc30_ = _loc30_^-2139062144;
     
187.                 _loc8_ = _loc30_ & _loc8_;
     
188.                 if (_loc8_ != 0) {
     
189.                         _loc8_ = _loc15_ & 255;
     
190.                         if (_loc8_ == 0) {
     
191.                                 _loc15_ = int(_loc6_ - _loc9_);
     
192.                         } else {
     
193.                                 _loc8_ = li8(_loc6_ + 1);
     
194.                                 if (_loc8_ == 0) {
     
195.                                         _loc8_ = int(1 - _loc9_);
     
196.                                         _loc15_ = int(_loc8_ + _loc6_);
     
197.                                 } else {
     
198.                                         _loc8_ = li8(_loc6_ + 2);
     
199.                                         if (_loc8_ == 0) {
     
200.                                                 _loc8_ = int(2 - _loc9_);
     
201.                                                 _loc15_ = int(_loc8_ + _loc6_);
     
202.                                         } else {
     
203.                                                 _loc8_ = li8(_loc6_ + 3);
     
204.                                                 if (_loc8_ == 0) {
     
205.                                                         _loc8_ = int(3 - _loc9_);
     
206.                                                         _loc15_ = int(_loc8_ + _loc6_);
     
207.                                                 } else {
     
208.                                                         continue;
     
209.                                                 }
     
210.                                         }
     
211.                                 }
     
212.                         }
     
213.                         §§goto(addr501);
     
214.                 }
     
215.         }
     
216. }

复制代码