-
Notifications
You must be signed in to change notification settings - Fork 4
/
Copy pathgadgets_list.txt
11791 lines (11790 loc) · 786 KB
/
gadgets_list.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
Gadgets information
============================================================
0x080aab28 : aaa ; add esp, 4 ; pop ebx ; pop esi ; ret
0x080b9689 : aaa ; push 1 ; push 1 ; call eax
0x080b9af2 : aaa ; push dword ptr [esp + 0xc] ; mov eax, dword ptr [esp + 0x14] ; call eax
0x080b90b1 : aaa ; push ecx ; push 1 ; call eax
0x080e5d3d : aad 0 ; add al, ah ; pop es ; sti ; call ebx
0x080be8f1 : aad 0xf9 ; call esp
0x080be8e1 : aad 0xf9 ; jmp edx
0x080d54a6 : aad 8 ; stosd dword ptr es:[edi], eax ; ret
0x080e8759 : aad ; push cs ; adc al, 0x43 ; ret
0x08098953 : aam 0 ; add byte ptr [eax], al ; mov eax, ebx ; pop ebx ; pop esi ; ret 8
0x080e85cc : aam 0x24 ; cld ; jmp dword ptr [edi]
0x08049d0a : aam 0x29 ; ret 0xea83
0x080b6ec8 : aam 0x52 ; cli ; inc dword ptr [ebx + 0x7d8010c4] ; ret
0x0808e99b : aam 0x5b ; ret
0x08081f44 : aam 0x83 ; call 0x17ca5852
0x08081dc0 : aam 0x83 ; rol byte ptr [ecx], 0x29 ; fidivr dword ptr [ecx] ; ret 0xee7f
0x0809cced : aam 0x8b ; pop ebp ; or al, 1 ; ret
0x08099cc2 : aam 0x8d ; hlt ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x080e5d3c : aam 0xd5 ; add byte ptr [eax], al ; loopne 0x80e5d50 ; sti ; call ebx
0x0804883d : aam 0xe ; or byte ptr [ecx], al ; leave ; ret
0x08084d2f : aam 0xe7 ; push cs ; or byte ptr [ebx - 0x7d], dl ; ret
0x080be919 : aam 0xf9 ; call dword ptr [ebx + 0x12fff9d4]
0x080be91d : aam 0xf9 ; call dword ptr [edx]
0x080be8dd : aam 0xf9 ; dec dword ptr [edx - 0x2b] ; stc ; jmp edx
0x080be90d : aam 0xf9 ; jmp dword ptr [eax]
0x080be909 : aam 0xf9 ; jmp dword ptr [ecx + 0x20fff9d4]
0x080d3e64 : aas ; adc ebp, dword ptr [ebx] ; fstp dword ptr [ebx + 0x4a315a58] ; ret 0x1b49
0x080ead3d : aas ; add cl, byte ptr [edx] ; push cs ; adc al, 0x41 ; ret
0x080e8261 : aas ; add cl, byte ptr [edx] ; ret
0x080d2ca8 : aas ; mov ch, 0x31 ; mov ah, bl ; push esi ; ret
0x08062fe2 : adc ah, byte ptr [esi + 0xf] ; out dx, eax ; shl dword ptr [esi + 0xf], 1 ; cmp byte ptr [edi], dl ; ret 0x6273
0x0808c908 : adc al, 0x39 ; ret
0x0806c91e : adc al, 0x3e ; lea esp, dword ptr [ebp - 0xc] ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x080d88ac : adc al, 0x41 ; ret
0x080d8b3c : adc al, 0x43 ; ret
0x080dc2b6 : adc al, 0x44 ; ret
0x080d9582 : adc al, 0x45 ; ret
0x080d9759 : adc al, 0x46 ; ret
0x080d9b4f : adc al, 0x47 ; ret
0x080db763 : adc al, 0x48 ; ret
0x080de1dc : adc al, 0x4a ; ret
0x080e7952 : adc al, 0x4b ; push cs ; adc byte ptr [edi + 0xa], al ; ret
0x0808bdbf : adc al, 0x50 ; push esi ; push edi ; call ebx
0x0805900e : adc al, 0x51 ; call eax
0x080a67d5 : adc al, 0x51 ; push edx ; call eax
0x08058a76 : adc al, 0x56 ; call eax
0x080991ab : adc al, 0x5b ; pop edi ; ret
0x08084581 : adc al, 0x5b ; pop esi ; pop edi ; pop ebp ; ret
0x080bb11e : adc al, 0x5b ; pop esi ; pop edi ; ret
0x0804fc83 : adc al, 0x5b ; pop esi ; ret
0x080b380d : adc al, 0x5b ; ret
0x080bb080 : adc al, 0x5f ; ret
0x0808eae1 : adc al, 0x69 ; ret 0x5180
0x08094df1 : adc al, 0x6b ; ret
0x080de147 : adc al, 0x83 ; add eax, 0x100ea002 ; ret
0x080e657a : adc al, 0x83 ; add eax, 0x2300e45 ; ret 0xe0a
0x080e19e2 : adc al, 0x83 ; add eax, 0x2400e43 ; ret 0x4c0e
0x080930d2 : adc al, 0x83 ; in al, dx ; or byte ptr [ecx], ch ; ret 0x73ff
0x0804da45 : adc al, 0x83 ; jmp dword ptr [eax]
0x0808b65f : adc al, 0x83 ; les eax, ptr [ebx + ebx*2] ; pop esi ; jmp eax
0x0804ffe5 : adc al, 0x83 ; les eax, ptr [ebx + ebx*2] ; pop esi ; ret
0x080533b8 : adc al, 0x83 ; les ecx, ptr [eax] ; pop ebx ; jmp eax
0x080a5a7d : adc al, 0x83 ; les ecx, ptr [eax] ; pop ebx ; ret
0x080a6fd4 : adc al, 0x83 ; les ecx, ptr [ebx + ebx*2] ; ret
0x0804fea2 : adc al, 0x83 ; les edi, ptr [ebx + ebx*2] ; pop esi ; pop edi ; pop ebp ; ret
0x0809e2e3 : adc al, 0x83 ; ret 0x3c01
0x080ba2c4 : adc al, 0x83 ; ret 0x8301
0x08077079 : adc al, 0x83 ; ret 0xc704
0x0807671e : adc al, 0x85 ; ror byte ptr [edi], 0x84 ; ret 0
0x0804d43e : adc al, 0x89 ; push 0xc ; mov dword ptr [edx + 0x18], eax ; ret
0x08056fe5 : adc al, 0x89 ; ret
0x080742eb : adc al, 0x89 ; ret 0x448d
0x08056d6d : adc al, 0x89 ; ret 0x48b
0x080b0a07 : adc al, 0x89 ; ret 0xc483
0x080bb17c : adc al, 0x89 ; ret 0xf089
0x08095f0c : adc al, 0x8a ; mov dword ptr [eax + 0x18c], edx ; ret
0x08050d13 : adc al, 0x8b ; inc ebp ; adc byte ptr [ecx], bh ; ret 0x44c7
0x0808ba54 : adc al, 0x91 ; mov dword ptr [eax], edx ; xor eax, eax ; pop ebx ; pop esi ; ret
0x0809159d : adc al, 0x9a ; add eax, dword ptr [edx + ecx] ; pop ebx ; pop esi ; ret
0x080a6902 : adc al, 0xc1 ; call 0x91cc922d
0x08080a02 : adc al, 0xc7 ; ret
0x0806e7d5 : adc al, 0xc7 ; ret 0xffe8
0x08070158 : adc al, 0xf ; inc edi ; ret 0xc183
0x0805ab3c : adc al, 0xf6 ; ret
0x0804d75f : adc al, 1 ; add esi, 4 ; mov dword ptr [ebp], eax ; jmp 0x804d734
0x08054ed7 : adc al, 1 ; mov eax, edx ; ret
0x0808fb02 : adc al, 1 ; ret 0x1589
0x080a6b68 : adc al, 1 ; ret 0xf889
0x0807a81a : adc al, 8 ; pop ebx ; ret
0x080482e2 : adc al, bh ; ret 0xffe8
0x08087e35 : adc al, byte ptr [eax] ; add byte ptr [eax + 0x50], dl ; push 0x2b ; jmp 0x8087e09
0x080d99b1 : adc al, byte ptr [eax] ; add byte ptr [ebx + edx*2 - 9], bh ; call dword ptr [esi]
0x08087d6e : adc al, byte ptr [eax] ; add byte ptr [edx + 0x52], dl ; push 0x2b ; jmp 0x8087d42
0x08084617 : adc al, byte ptr [ebp - 0x76e38a2e] ; ret 0x542b
0x08066a52 : adc al, byte ptr [ecx] ; movlpd qword ptr [edx], xmm0 ; lea eax, dword ptr [edx + 7] ; ret
0x08064fc2 : adc al, byte ptr [ecx] ; movlpd qword ptr [edx], xmm0 ; mov eax, edi ; pop edi ; ret
0x080651e2 : adc al, byte ptr [ecx] ; movlpd qword ptr [edx], xmm0 ; mov eax, edx ; ret
0x080e6fb5 : adc al, byte ptr [ecx] ; or cl, byte ptr [esi] ; adc al, 0x41 ; ret
0x080dcdb3 : adc al, byte ptr [esi + ecx - 0x50] ; adc cl, byte ptr [ebx + 0xe] ; adc al, 0x43 ; ret
0x0806d4c7 : adc al, ch ; ret
0x080689f5 : adc al, dh ; ret
0x0807f8ac : adc bh, al ; test dword ptr [ebx + edi*8 - 1], esi ; call dword ptr [eax]
0x0804c22a : adc bh, dl ; push cs ; or byte ptr [ecx], ch ; ret 0x5be8
0x080b9056 : adc bl, byte ptr [ebx - 0x77] ; push esi ; dec esp ; pop esi ; pop edi ; ret
0x080b652d : adc bl, byte ptr [esi + 0x5d] ; xor eax, eax ; ret
0x0806f41c : adc bl, ch ; loope 0x806f3b5 ; ret
0x0806dadf : adc bl, ch ; ret
0x080e2a31 : adc byte ptr [eax + 0xa], ch ; ret
0x080e29e4 : adc byte ptr [eax + 0xa], cl ; push cs ; or al, 0x41 ; ret
0x080dca95 : adc byte ptr [eax + 0xa], dh ; push cs ; or al, 0x41 ; ret
0x080e308e : adc byte ptr [eax + 0xa], dl ; push cs ; or al, 0x41 ; ret
0x080dfbed : adc byte ptr [eax + 0xa], dl ; push cs ; or al, 0x43 ; ret
0x080e425f : adc byte ptr [eax + 0xe], bl ; or al, 0x41 ; ret
0x080e310c : adc byte ptr [eax + 0xe], dl ; or al, 0x41 ; ret
0x080537c4 : adc byte ptr [eax + 1], bh ; add esp, 0xc ; ret
0x0808bbda : adc byte ptr [eax + 1], bh ; pop ebx ; pop esi ; pop edi ; ret
0x0808bbca : adc byte ptr [eax + 2], bh ; pop ebx ; pop esi ; pop edi ; ret
0x080724c6 : adc byte ptr [eax - 0x76d00088], al ; ret 0x674
0x0809b58b : adc byte ptr [eax - 0x7cf7f132], bl ; les ecx, ptr [eax] ; pop ebx ; jmp eax
0x08068a25 : adc byte ptr [eax], ah ; ret
0x0808db6b : adc byte ptr [eax], al ; add byte ptr [eax], al ; pop edi ; ret
0x080997ee : adc byte ptr [eax], al ; add byte ptr [ebx + 0x5e], bl ; pop edi ; ret
0x08099793 : adc byte ptr [eax], al ; add byte ptr [ecx + 0x5f5e5bd8], cl ; ret
0x080488e3 : adc byte ptr [eax], bh ; leave ; ret
0x0805f794 : adc byte ptr [eax], bh ; ret 0x840f
0x0806c40f : adc byte ptr [eax], dh ; ret 0x806
0x08099792 : adc byte ptr [eax], dl ; add byte ptr [eax], al ; mov eax, ebx ; pop ebx ; pop esi ; pop edi ; ret
0x080997ed : adc byte ptr [eax], dl ; add byte ptr [eax], al ; pop ebx ; pop esi ; pop edi ; ret
0x08068a15 : adc byte ptr [eax], dl ; ret
0x080bc0f9 : adc byte ptr [ebp + 0x5bd275f6], al ; pop esi ; pop edi ; ret
0x080bc404 : adc byte ptr [ebp + 0x5bdf75f6], al ; pop esi ; pop edi ; ret
0x0804bf7c : adc byte ptr [ebp + 0x5e5bf465], cl ; pop edi ; pop ebp ; ret
0x08084827 : adc byte ptr [ebp + 0x5e5bf465], cl ; pop edi ; pop ebp ; ret 4
0x080504cb : adc byte ptr [ebp + 0x740689c0], al ; ret
0x080e15a2 : adc byte ptr [ebp + 0xa], al ; ret
0x080e30f5 : adc byte ptr [ebp + 0xa], bh ; push cs ; or al, 0x41 ; ret
0x080d9909 : adc byte ptr [ebp + 0xa], bl ; ret
0x080db12b : adc byte ptr [ebp + 0xa], ch ; ret
0x080d8c35 : adc byte ptr [ebp + 0xa], cl ; push cs ; or al, 0x41 ; ret
0x080d9de7 : adc byte ptr [ebp + 0xa], cl ; push cs ; or al, 0x46 ; ret
0x080df88e : adc byte ptr [ebp + 0xa], dl ; push cs ; or al, 0x41 ; ret
0x0806e112 : adc byte ptr [ebp - 0x72e68b40], al ; push ebx ; add al, 0x83 ; ret
0x0805736f : adc byte ptr [ebp - 0x74cf7aa4], cl ; inc ebx ; or byte ptr [ecx], bh ; ret
0x0807527b : adc byte ptr [ebp - 0x760352b4], cl ; ret 0xead3
0x0807854c : adc byte ptr [ebp - 0x76397640], al ; ret
0x0806eb23 : adc byte ptr [ebp - 0x76818b40], al ; ret
0x0807226a : adc byte ptr [ebp - 0x76bc8b40], al ; ret
0x080b5157 : adc byte ptr [ebp - 0x79f00f93], cl ; call dword ptr [eax]
0x080bad53 : adc byte ptr [ebp - 0x7c2f8740], al ; ret
0x08098911 : adc byte ptr [ebp - 0x7cb58a40], al ; in al, dx ; or al, 0x89 ; ret
0x08098e17 : adc byte ptr [ebp - 0x7cbb8740], al ; in al, dx ; add al, 0x89 ; ret
0x08072a17 : adc byte ptr [ebp - 0x7cdb8b40], al ; ret
0x0809b0b2 : adc byte ptr [ebx + 0x39013069], al ; ret 0xdc75
0x080baba2 : adc byte ptr [ebx + 0x39082454], cl ; ret 0x830f
0x0809cce0 : adc byte ptr [ebx + 0x458920c4], al ; in al, 1 ; ret
0x0808b77f : adc byte ptr [ebx + 0x5e5b04c4], al ; jmp eax
0x08054f5a : adc byte ptr [ebx + 0x5e5b04c4], al ; pop edi ; pop ebp ; ret
0x08055709 : adc byte ptr [ebx + 0x5e5b04c4], al ; ret
0x08058ef3 : adc byte ptr [ebx + 0x5e5b0cc4], al ; pop edi ; pop ebp ; ret
0x0805307c : adc byte ptr [ebx + 0x5e5b10c4], al ; pop edi ; ret
0x0809885a : adc byte ptr [ebx + 0x5e5b10c4], al ; pop edi ; ret 4
0x08052e4c : adc byte ptr [ebx + 0x5e5b1cc4], al ; pop edi ; pop ebp ; ret
0x0808c000 : adc byte ptr [ebx + 0x5e5b2cc4], al ; pop edi ; pop ebp ; ret
0x0808de06 : adc byte ptr [ebx + 0x5e5b30c4], al ; pop edi ; ret
0x08055d96 : adc byte ptr [ebx + 0x5e5b3cc4], al ; pop edi ; pop ebp ; ret
0x0806ca7b : adc byte ptr [ebx + 0x5e5b4cc4], al ; pop edi ; pop ebp ; ret
0x0805b646 : adc byte ptr [ebx + 0x5e5b5cc4], al ; pop edi ; pop ebp ; ret
0x080517a7 : adc byte ptr [ebx + 0x5e], bl ; pop edi ; mov eax, dword ptr [eax + 0x20] ; jmp eax
0x0805b11d : adc byte ptr [ebx + 0x5e], bl ; pop edi ; pop ebp ; ret
0x080509f4 : adc byte ptr [ebx + 0x5e], bl ; pop edi ; ret
0x0809885d : adc byte ptr [ebx + 0x5e], bl ; pop edi ; ret 4
0x0809c3e1 : adc byte ptr [ebx + 0x5e], bl ; ret
0x080a5cf4 : adc byte ptr [ebx + 0x5f5e04c4], al ; ret
0x080df4d9 : adc byte ptr [ebx + 0xa400204], al ; ret
0x080e3d39 : adc byte ptr [ebx + 0xa460204], al ; ret
0x080e1a79 : adc byte ptr [ebx + 0xa480204], al ; ret
0x080ea559 : adc byte ptr [ebx + 0xa530204], al ; ret
0x080dabb5 : adc byte ptr [ebx + 0xa570204], al ; ret
0x080e4589 : adc byte ptr [ebx + 0xa690204], al ; ret
0x080e5c2d : adc byte ptr [ebx + 0xa770204], al ; ret
0x080dc52d : adc byte ptr [ebx + 0xa830204], al ; ret
0x080daa13 : adc byte ptr [ebx + 0xa], ah ; ret
0x080dbd21 : adc byte ptr [ebx + 0xa], al ; push cs ; or al, 0x41 ; ret
0x080da90d : adc byte ptr [ebx + 0xa], al ; ret
0x080db47d : adc byte ptr [ebx + 0xa], ch ; push cs ; or al, 0x41 ; ret
0x080db295 : adc byte ptr [ebx + 0xa], cl ; push cs ; or al, 0x41 ; ret
0x080deffd : adc byte ptr [ebx + 0xc0e6004], al ; ret
0x0805f78e : adc byte ptr [ebx - 0x167cef3e], al ; adc byte ptr [eax], bh ; ret 0x840f
0x08088dc1 : adc byte ptr [ebx - 0x199f7afc], cl ; or al, 8 ; jmp eax
0x080b3879 : adc byte ptr [ebx - 0x2776d73c], al ; pop ebx ; ret
0x080b37de : adc byte ptr [ebx - 0x2776e73c], al ; pop ebx ; ret
0x0808b29a : adc byte ptr [ebx - 0x2f76f73c], al ; pop ebx ; ret
0x0808b65c : adc byte ptr [ebx - 0x3b7cebc0], cl ; add al, 0x5b ; pop esi ; jmp eax
0x0808b77c : adc byte ptr [ebx - 0x3b7cefc0], cl ; add al, 0x5b ; pop esi ; jmp eax
0x0808b2df : adc byte ptr [ebx - 0x3b7cf3c0], cl ; add al, 0x5b ; pop esi ; jmp eax
0x0806d0c4 : adc byte ptr [ebx - 0x47f3dba4], cl ; ret
0x0804c272 : adc byte ptr [ebx - 0x76c3db94], cl ; ret
0x08087036 : adc byte ptr [ebx - 0x7af00008], al ; ret
0x0809e55a : adc byte ptr [ebx - 0x7bf0fb08], al ; ret
0x08088640 : adc byte ptr [ebx - 0x7bf0fe40], al ; ret
0x080b24d4 : adc byte ptr [ebx - 0x7c83dbb4], cl ; ret 0x83ff
0x080af72f : adc byte ptr [ebx - 0x7c8bdbb4], cl ; ret 0x83ff
0x0809d6cb : adc byte ptr [ebx - 0x7cb7dbb4], cl ; ret 0xeb04
0x0809d423 : adc byte ptr [ebx - 0x7cf3dbac], cl ; mov byte ptr [ecx], 0x83 ; ret
0x080b9507 : adc byte ptr [ebx - 0x7cf3dbbc], cl ; les ebx, ptr [eax] ; pop ebx ; ret
0x0806cac5 : adc byte ptr [ebx], al ; add byte ptr [ebx + 0x5e], bl ; pop edi ; pop ebp ; ret
0x080dc5cb : adc byte ptr [ebx], al ; lahf ; add dword ptr [edx], ecx ; push cs ; or al, 0x41 ; ret
0x0809c4ac : adc byte ptr [ecx + 0x1cc483d0], cl ; ret
0x080a6163 : adc byte ptr [ecx + 0x2cc483d0], cl ; ret
0x080549c5 : adc byte ptr [ecx + 0x5b0cc483], bl ; pop esi ; pop edi ; pop ebp ; ret
0x080805a6 : adc byte ptr [ecx + 0x5bf08903], cl ; pop esi ; pop edi ; ret
0x080586a6 : adc byte ptr [ecx + 0x5f5e5bd8], cl ; ret
0x08051fb3 : adc byte ptr [ecx + 0x5f5e5bf0], cl ; ret
0x08098e4f : adc byte ptr [ecx + 0x60c483f0], cl ; pop ebx ; pop esi ; pop edi ; ret
0x080dc54c : adc byte ptr [ecx + 0xa], al ; ret
0x080de468 : adc byte ptr [ecx + 0xa], cl ; push cs ; or al, 0x41 ; ret
0x080e7bd5 : adc byte ptr [ecx + 0xa], dl ; push cs ; or al, 0x41 ; ret
0x080dbb36 : adc byte ptr [ecx + 0xa], dl ; ret
0x080502de : adc byte ptr [ecx - 0x7627d608], cl ; ret
0x080531b0 : adc byte ptr [ecx - 0x7c3fceed], cl ; les ecx, ptr [eax] ; pop ebx ; ret
0x0804ff94 : adc byte ptr [ecx - 0x9ec74ce], cl ; ret 0x7402
0x0808050b : adc byte ptr [ecx - 0xf766efc], cl ; pop ebx ; pop esi ; pop edi ; ret
0x08091599 : adc byte ptr [ecx], ah ; ret
0x08067c26 : adc byte ptr [ecx], al ; clc ; pop edi ; ret
0x080a8b91 : adc byte ptr [ecx], al ; ret
0x08056e1f : adc byte ptr [ecx], al ; ret 0x1589
0x080a34b0 : adc byte ptr [ecx], al ; ret 0xcc29
0x0807bdc5 : adc byte ptr [ecx], bh ; enter 0x2673, -0x77 ; ret 0xf189
0x0805b7cd : adc byte ptr [ecx], bh ; ret
0x08099771 : adc byte ptr [ecx], bh ; ret 0x1172
0x0809b092 : adc byte ptr [ecx], bh ; ret 0x2474
0x0807ccc8 : adc byte ptr [ecx], bh ; ret 0x387f
0x08050d16 : adc byte ptr [ecx], bh ; ret 0x44c7
0x0807ccba : adc byte ptr [ecx], bh ; ret 0x5975
0x0807d102 : adc byte ptr [ecx], bh ; ret 0x850f
0x0807d11f : adc byte ptr [ecx], bh ; ret 0x870f
0x08050a05 : adc byte ptr [ecx], bh ; ret 0xa674
0x0805032f : adc byte ptr [ecx], ch ; ret
0x080a6a5e : adc byte ptr [ecx], cl ; ret 0x1b9
0x080586ea : adc byte ptr [ecx], dh ; fisttp dword ptr [ecx + 0x5f5e5bd8] ; ret
0x0808bbee : adc byte ptr [ecx], dh ; rcr byte ptr [ebx + 0x5e], 0x5f ; ret
0x08050776 : adc byte ptr [ecx], dh ; sar byte ptr [ecx], cl ; fimul word ptr [edi] ; xchg eax, esp ; ret 0x4d8b
0x080e8629 : adc byte ptr [edi + 0xa], ah ; push cs ; or al, 0x41 ; ret
0x080e5cf4 : adc byte ptr [edi + 0xa], al ; push cs ; or al, 0x41 ; ret
0x080dea0e : adc byte ptr [edi + 0xa], al ; push cs ; or al, 0x43 ; ret
0x080e60a6 : adc byte ptr [edi + 0xa], al ; push cs ; or al, 0x46 ; ret
0x080d8b93 : adc byte ptr [edi + 0xa], al ; ret
0x080e610e : adc byte ptr [edi + 0xa], cl ; push cs ; or al, 0x43 ; ret
0x080d8e0e : adc byte ptr [edi + 0xe], al ; or al, 0x41 ; ret
0x0808d4ba : adc byte ptr [edi - 0x3d], bl ; lea esi, dword ptr [esi] ; xor eax, eax ; pop edi ; ret
0x08051c7f : adc byte ptr [edi], cl ; mov dh, 0 ; add esp, 8 ; pop ebx ; ret
0x080818ea : adc byte ptr [edi], cl ; scasd eax, dword ptr es:[edi] ; ret 0x958b
0x0808d8f2 : adc byte ptr [edi], cl ; test dword ptr [edi - 0xa000000], esp ; ret 0xf20
0x0808d7d2 : adc byte ptr [edi], cl ; test dword ptr [esi - 0x9fffffd], esi ; ret 0xf20
0x0806787b : adc byte ptr [edi], cl ; test edi, esi ; add dword ptr [eax], eax ; add dh, dh ; ret 0xf10
0x080b6657 : adc byte ptr [edi], cl ; xchg byte ptr [ebx - 0x7cfffffe], al ; ret 0x8310
0x080b90e9 : adc byte ptr [edi], cl ; xchg eax, esp ; ret
0x080d9dc9 : adc byte ptr [edx + 0xa], ch ; push cs ; or al, 0x41 ; ret
0x080d9e92 : adc byte ptr [edx + 0xa], cl ; ret
0x080ea735 : adc byte ptr [edx + 0xe], bh ; or al, 0x41 ; ret
0x080e6538 : adc byte ptr [edx + ecx + 0xe], dl ; or al, 0x41 ; ret
0x080de2b1 : adc byte ptr [edx], al ; dec ecx ; or cl, byte ptr [esi] ; or al, 0x41 ; ret
0x080e30c5 : adc byte ptr [edx], al ; dec esp ; or cl, byte ptr [esi] ; or al, 0x46 ; ret
0x080de41d : adc byte ptr [edx], al ; inc ecx ; or cl, byte ptr [esi] ; or al, 0x41 ; ret
0x080de9ed : adc byte ptr [edx], al ; inc esp ; or cl, byte ptr [esi] ; or al, 0x43 ; ret
0x080e3055 : adc byte ptr [edx], al ; insb byte ptr es:[edi], dx ; or cl, byte ptr [esi] ; or al, 0x46 ; ret
0x080dc8b4 : adc byte ptr [edx], al ; mov ecx, 0x43080e0a ; ret
0x080dc2f5 : adc byte ptr [edx], al ; mov word ptr [edx], cs ; push cs ; or al, 0x45 ; ret
0x080df30d : adc byte ptr [edx], al ; or cl, byte ptr [esi] ; adc al, 0x41 ; ret
0x080e6605 : adc byte ptr [edx], al ; push ebx ; push cs ; or al, 0x41 ; ret
0x080da4f6 : adc byte ptr [esi + 0xa], ah ; ret
0x080df8f6 : adc byte ptr [esi + 0xa], cl ; push cs ; or al, 0x41 ; ret
0x080e2ff1 : adc byte ptr [esi + 0xa], dh ; push cs ; or al, 0x41 ; ret
0x080def8d : adc byte ptr [esi + 0xa], dl ; push cs ; or al, 0x41 ; ret
0x080deceb : adc byte ptr [esi + 0xa], dl ; ret
0x080e388b : adc byte ptr [esi + 0xc0e4204], al ; ret
0x080e38fa : adc byte ptr [esi + 0xc0e4a04], al ; ret
0x080e38e9 : adc byte ptr [esi + 0xc0e4d04], al ; ret
0x080e394f : adc byte ptr [esi + 0xc0e4f04], al ; ret
0x080e38c7 : adc byte ptr [esi + 0xc0e7104], al ; ret
0x080e3b59 : adc byte ptr [esi + 0xc0e7204], al ; ret
0x080e38d8 : adc byte ptr [esi + 0xc0e7304], al ; ret
0x080e38b6 : adc byte ptr [esi + 0xc0e7504], al ; ret
0x08062ff7 : adc byte ptr [esi + 0xf], ah ; out dx, eax ; shl dword ptr [esi + 0xf], 1 ; cmp byte ptr [edi], dl ; ret 0x5073
0x080b3ee3 : adc byte ptr [esi + 0xf], ah ; outsd dx, dword ptr [esi] ; fsub st(1), st(0) ; ret
0x08067d12 : adc byte ptr [esi + 0xf], ah ; xlatb ; ret
0x08067cfa : adc byte ptr [esi + 0xf], ah ; xlatb ; ret 0xc085
0x080e2ed1 : adc byte ptr [esi + ecx + 0xc], dl ; inc ecx ; ret
0x080da9bc : adc byte ptr [esi + ecx + 8], ah ; inc ecx ; ret
0x080dac70 : adc byte ptr [esi - 9], bh ; call ebx
0x080e2a30 : adc byte ptr cs:[eax + 0xa], ch ; ret
0x080d9908 : adc byte ptr cs:[ebp + 0xa], bl ; ret
0x080a4265 : adc ch, cl ; mov dword ptr [0x89ffffdf], eax ; ret 0xc001
0x080dcdb7 : adc cl, byte ptr [ebx + 0xe] ; adc al, 0x43 ; ret
0x08092535 : adc cl, ch ; ret
0x080b2cfb : adc cl, ch ; ret 0xffe6
0x080b2b13 : adc cl, ch ; ret 0xfffd
0x080487c7 : adc cl, cl ; ret
0x080981ff : adc dh, dh ; ret
0x0804c8ed : adc dh, dh ; ret 0x74bf
0x0804c87c : adc dh, dh ; ret 0xfbf
0x08078de2 : adc dword ptr [eax + ecx], ecx ; test eax, eax ; je 0x8078df2 ; call eax
0x0806d371 : adc dword ptr [eax - 1], edi ; jmp 0x806d316
0x0809124c : adc dword ptr [eax - 1], edi ; pop ebx ; pop esi ; ret
0x080508cb : adc dword ptr [eax - 1], edi ; pop ebx ; ret
0x0804eb8e : adc dword ptr [ebp - 0x2f76079b], ecx ; pop ebx ; pop esi ; pop ebp ; ret
0x08072cf0 : adc dword ptr [ebx + 0x5e5b3cc4], eax ; pop edi ; pop ebp ; ret
0x08077a95 : adc dword ptr [ebx + 0x5e5b5cc4], eax ; pop edi ; pop ebp ; ret
0x080dd376 : adc dword ptr [ecx], eax ; push cs ; or byte ptr [ebx + 0x40e4f02], al ; ret
0x0809d233 : adc dword ptr [ecx], eax ; sar byte ptr [ecx], 1 ; ret 0x189
0x0806c829 : adc dword ptr [edx], 0x3d ; add byte ptr [eax], al ; ret
0x0804de54 : adc eax, 0x18 ; call edx
0x0806824a : adc eax, 0x29c0bc0f ; ret 0x860f
0x08084437 : adc eax, 0x5bfffea9 ; mov eax, edx ; pop esi ; pop edi ; ret
0x0807037a : adc eax, 0x80ec4cc ; add esp, 8 ; pop ebx ; ret
0x0808e9cb : adc eax, 0x80eceb0 ; pop ebx ; ret
0x0806ed6b : adc eax, 0x80eceb0 ; pop edx ; pop ecx ; pop ebx ; ret
0x08091196 : adc eax, 0x80eceb0 ; ret
0x0807a752 : adc eax, 0x80ed39c ; je 0x807a769 ; pop ebx ; pop esi ; ret
0x080e9d49 : adc eax, 0x9aa40001 ; cld ; jmp dword ptr [eax]
0x0809854f : adc eax, 0xf601eb83 ; ret
0x0808edb8 : adc eax, dword ptr [ebx + 0x5e5b1cc4] ; pop edi ; pop ebp ; ret
0x0807392e : adc eax, dword ptr [ebx + eax*4] ; ret 0x8b01
0x0806bdbf : adc eax, dword ptr [ebx - 0x6bf0fd06] ; ret 0x5484
0x080df3e5 : adc eax, dword ptr [ecx] ; or cl, byte ptr [esi] ; adc al, 0x41 ; ret
0x0806757f : adc eax, dword ptr [edx + 5] ; lea eax, dword ptr [edx + 0xc] ; pop edi ; ret
0x080676df : adc eax, dword ptr [edx + 5] ; lea eax, dword ptr [edx + 0xc] ; ret
0x08066f6f : adc eax, dword ptr [edx + 5] ; mov eax, edi ; pop edi ; ret
0x080670cf : adc eax, dword ptr [edx + 5] ; mov eax, edx ; ret
0x0806759f : adc eax, dword ptr [edx + 6] ; lea eax, dword ptr [edx + 0xd] ; pop edi ; ret
0x080676ff : adc eax, dword ptr [edx + 6] ; lea eax, dword ptr [edx + 0xd] ; ret
0x08066f8f : adc eax, dword ptr [edx + 6] ; mov eax, edi ; pop edi ; ret
0x080670ef : adc eax, dword ptr [edx + 6] ; mov eax, edx ; ret
0x080675bf : adc eax, dword ptr [edx + 7] ; lea eax, dword ptr [edx + 0xe] ; pop edi ; ret
0x0806771f : adc eax, dword ptr [edx + 7] ; lea eax, dword ptr [edx + 0xe] ; ret
0x08066faf : adc eax, dword ptr [edx + 7] ; mov eax, edi ; pop edi ; ret
0x0806710f : adc eax, dword ptr [edx + 7] ; mov eax, edx ; ret
0x0806744e : adc eax, dword ptr [edx + 8] ; lea eax, dword ptr [edx + 0xf] ; pop edi ; ret
0x0806773f : adc eax, dword ptr [edx + 8] ; lea eax, dword ptr [edx + 0xf] ; ret
0x08066e5e : adc eax, dword ptr [edx + 8] ; mov eax, edi ; pop edi ; ret
0x0806712f : adc eax, dword ptr [edx + 8] ; mov eax, edx ; ret
0x08066816 : adc eax, dword ptr [edx] ; lea eax, dword ptr [edx + 7] ; pop edi ; ret
0x08066a56 : adc eax, dword ptr [edx] ; lea eax, dword ptr [edx + 7] ; ret
0x08066929 : adc eax, dword ptr [edx] ; mov byte ptr [edx + 8], al ; lea eax, dword ptr [edx + 8] ; pop edi ; ret
0x08066a69 : adc eax, dword ptr [edx] ; mov byte ptr [edx + 8], al ; lea eax, dword ptr [edx + 8] ; ret
0x080650b9 : adc eax, dword ptr [edx] ; mov byte ptr [edx + 8], al ; mov eax, edi ; pop edi ; ret
0x080651f9 : adc eax, dword ptr [edx] ; mov byte ptr [edx + 8], al ; mov eax, edx ; ret
0x08066969 : adc eax, dword ptr [edx] ; mov dword ptr [edx + 7], eax ; lea eax, dword ptr [edx + 0xa] ; pop edi ; ret
0x08066aa9 : adc eax, dword ptr [edx] ; mov dword ptr [edx + 7], eax ; lea eax, dword ptr [edx + 0xa] ; ret
0x080650f9 : adc eax, dword ptr [edx] ; mov dword ptr [edx + 7], eax ; mov eax, edi ; pop edi ; ret
0x08065239 : adc eax, dword ptr [edx] ; mov dword ptr [edx + 7], eax ; mov eax, edx ; ret
0x08066859 : adc eax, dword ptr [edx] ; mov dword ptr [edx + 8], eax ; lea eax, dword ptr [edx + 0xb] ; pop edi ; ret
0x08066ac9 : adc eax, dword ptr [edx] ; mov dword ptr [edx + 8], eax ; lea eax, dword ptr [edx + 0xb] ; ret
0x08065009 : adc eax, dword ptr [edx] ; mov dword ptr [edx + 8], eax ; mov eax, edi ; pop edi ; ret
0x08065259 : adc eax, dword ptr [edx] ; mov dword ptr [edx + 8], eax ; mov eax, edx ; ret
0x08064fc6 : adc eax, dword ptr [edx] ; mov eax, edi ; pop edi ; ret
0x080651e6 : adc eax, dword ptr [edx] ; mov eax, edx ; ret
0x08066a8a : adc eax, dword ptr [edx] ; mov word ptr [edx + 8], ax ; lea eax, dword ptr [edx + 9] ; ret
0x080650da : adc eax, dword ptr [edx] ; mov word ptr [edx + 8], ax ; mov eax, edi ; pop edi ; ret
0x0806521a : adc eax, dword ptr [edx] ; mov word ptr [edx + 8], ax ; mov eax, edx ; ret
0x0806527b : adc eax, dword ptr [edx] ; movlpd qword ptr [edx + 5], xmm1 ; mov eax, edx ; ret
0x0806529b : adc eax, dword ptr [edx] ; movlpd qword ptr [edx + 6], xmm1 ; mov eax, edx ; ret
0x080652bb : adc eax, dword ptr [edx] ; movlpd qword ptr [edx + 7], xmm1 ; mov eax, edx ; ret
0x080d3e65 : adc ebp, dword ptr [ebx] ; fstp dword ptr [ebx + 0x4a315a58] ; ret 0x1b49
0x0807a77a : adc ebx, dword ptr [ebx + 0x5e] ; ret
0x08079888 : adc ecx, dword ptr [ebp + 0x5e5bf465] ; pop edi ; pop ebp ; ret
0x0809bcdb : adc ecx, dword ptr [ebp - 0x7cffd98c] ; ret
0x0807b816 : adc ecx, dword ptr [edi] ; test dword ptr [ebx - 0x7d000000], eax ; ret 0x3901
0x0806698f : adc ecx, dword ptr [edx + 5] ; lea eax, dword ptr [edx + 0xc] ; pop edi ; ret
0x08066aef : adc ecx, dword ptr [edx + 5] ; lea eax, dword ptr [edx + 0xc] ; ret
0x0806511f : adc ecx, dword ptr [edx + 5] ; mov eax, edi ; pop edi ; ret
0x0806527f : adc ecx, dword ptr [edx + 5] ; mov eax, edx ; ret
0x080669af : adc ecx, dword ptr [edx + 6] ; lea eax, dword ptr [edx + 0xd] ; pop edi ; ret
0x08066b0f : adc ecx, dword ptr [edx + 6] ; lea eax, dword ptr [edx + 0xd] ; ret
0x0806513f : adc ecx, dword ptr [edx + 6] ; mov eax, edi ; pop edi ; ret
0x0806529f : adc ecx, dword ptr [edx + 6] ; mov eax, edx ; ret
0x080669cf : adc ecx, dword ptr [edx + 7] ; lea eax, dword ptr [edx + 0xe] ; pop edi ; ret
0x08066b2f : adc ecx, dword ptr [edx + 7] ; lea eax, dword ptr [edx + 0xe] ; ret
0x0806515f : adc ecx, dword ptr [edx + 7] ; mov eax, edi ; pop edi ; ret
0x080652bf : adc ecx, dword ptr [edx + 7] ; mov eax, edx ; ret
0x0804e7e4 : adc edi, dword ptr [ecx] ; ret 0x8d0f
0x0806d169 : adc edx, 0x33 ; add byte ptr [eax], al ; ret
0x0809a4ae : adc edx, dword ptr [eax - 0x7cfe397d] ; ret
0x0807bb0a : adc esi, dword ptr [ebp - 0x15] ; mov eax, ebx ; pop ebx ; pop esi ; pop edi ; ret
0x080d537a : adc esi, dword ptr [ebp - 0x60001a67] ; mov dh, 0xc7 ; ret 0xe71f
0x0804ff98 : adc esi, esi ; ret 0x7402
0x080ded4b : add ah, ah ; add byte ptr gs:[eax], al ; sal bh, 0xf8 ; jmp dword ptr [edx]
0x080e44ab : add ah, ah ; lodsd eax, dword ptr [esi] ; cli ; call dword ptr [esi]
0x080dc82b : add ah, al ; inc eax ; add byte ptr [eax], al ; ror ch, 0xf7 ; jmp dword ptr [ebx]
0x080e58ab : add ah, al ; out dx, al ; cli ; jmp eax
0x080e730b : add ah, al ; pushal ; sti ; call esp
0x080e2b43 : add ah, bh ; jg 0x80e2b45 ; jmp dword ptr [edx]
0x080e1463 : add ah, bh ; mov word ptr [eax], es ; add al, bl ; cmp ecx, 0xff ; ret 3
0x080d97d5 : add ah, bh ; or cl, byte ptr [esi] ; adc al, 0x41 ; ret
0x080e8243 : add ah, bl ; cli ; add byte ptr [eax], al ; pop eax ; or edi, esp ; jmp dword ptr [eax]
0x080e1c43 : add ah, bl ; xchg eax, esp ; add byte ptr [eax], al ; call 0x290e15f8
0x080d919a : add ah, byte ptr [eax + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080dfbb4 : add ah, byte ptr [ebp + 0xa] ; ret
0x080d904d : add ah, byte ptr [edx + ecx + 0xe] ; adc al, 0x41 ; ret
0x080db810 : add ah, byte ptr [edx + ecx + 0xe] ; adc al, 0x43 ; ret
0x080dc6c4 : add ah, byte ptr [esi + 0x43140e0a] ; ret
0x080ea9d8 : add ah, byte ptr [esi + 0xa] ; ret
0x080dba38 : add ah, byte ptr [esi + 0xe] ; adc al, 0x41 ; ret
0x08066aec : add ah, byte ptr [esi + 0xf] ; adc ecx, dword ptr [edx + 5] ; lea eax, dword ptr [edx + 0xc] ; ret
0x0806511c : add ah, byte ptr [esi + 0xf] ; adc ecx, dword ptr [edx + 5] ; mov eax, edi ; pop edi ; ret
0x0806527c : add ah, byte ptr [esi + 0xf] ; adc ecx, dword ptr [edx + 5] ; mov eax, edx ; ret
0x08066b0c : add ah, byte ptr [esi + 0xf] ; adc ecx, dword ptr [edx + 6] ; lea eax, dword ptr [edx + 0xd] ; ret
0x0806513c : add ah, byte ptr [esi + 0xf] ; adc ecx, dword ptr [edx + 6] ; mov eax, edi ; pop edi ; ret
0x0806529c : add ah, byte ptr [esi + 0xf] ; adc ecx, dword ptr [edx + 6] ; mov eax, edx ; ret
0x08066b2c : add ah, byte ptr [esi + 0xf] ; adc ecx, dword ptr [edx + 7] ; lea eax, dword ptr [edx + 0xe] ; ret
0x0806515c : add ah, byte ptr [esi + 0xf] ; adc ecx, dword ptr [edx + 7] ; mov eax, edi ; pop edi ; ret
0x080652bc : add ah, byte ptr [esi + 0xf] ; adc ecx, dword ptr [edx + 7] ; mov eax, edx ; ret
0x0805c059 : add ah, byte ptr [esi - 0x5b] ; rep movsd dword ptr es:[edi], dword ptr [esi] ; xchg eax, edi ; mov esi, edx ; ret
0x080def53 : add ah, ch ; add byte ptr [bx + si], al ; js 0x80def5e ; clc ; call dword ptr [eax]
0x080de033 : add ah, ch ; cmpsd dword ptr [esi], dword ptr es:[edi] ; clc ; call dword ptr [ebx]
0x080e4ce3 : add ah, ch ; ret
0x080e1963 : add ah, ch ; wait ; stc ; call dword ptr [ebx]
0x080d88f3 : add ah, cl ; add esi, edi ; jmp dword ptr [edx]
0x080dc29c : add ah, cl ; or cl, byte ptr [esi] ; adc al, 0x41 ; ret
0x080e5d3b : add ah, dl ; aad 0 ; add al, ah ; pop es ; sti ; call ebx
0x080e85cb : add ah, dl ; and al, 0xfc ; jmp dword ptr [edi]
0x080dc1b8 : add ah, dl ; or cl, byte ptr [esi] ; adc al, 0x43 ; ret
0x080b9c00 : add al, 0 ; add byte ptr [eax], al ; pop ebx ; ret
0x0808da8e : add al, 0 ; add byte ptr [eax], al ; pop edi ; ret
0x0808e911 : add al, 0 ; add byte ptr [eax], al ; ret
0x0804e044 : add al, 0 ; add byte ptr [eax], al ; xor eax, eax ; add esp, 0xc ; ret
0x0805b4a4 : add al, 0 ; add byte ptr [ebx + 0x5e], bl ; pop edi ; pop ebp ; ret
0x080ae8ae : add al, 0 ; add byte ptr [ebx - 0x27], bl ; loopne 0x80ae91c ; pop edi ; pop ebp ; ret
0x0804cdac : add al, 0 ; add byte ptr [ecx + 0x5f5e5bf0], cl ; pop ebp ; ret
0x08055d76 : add al, 0 ; add byte ptr [ecx], bh ; ret
0x0805b565 : add al, 0 ; add byte ptr [ecx], dh ; rcr byte ptr [ebx + 0x5e], 0x5f ; pop ebp ; ret
0x0809f1d1 : add al, 0 ; add byte ptr [edi], cl ; dec esi ; ret 0xec83
0x080ae225 : add al, 0 ; add cl, bl ; out dx, al ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x080afdb7 : add al, 0 ; add cl, ch ; ret
0x08055cb0 : add al, 0 ; add dh, dh ; ret
0x0809124b : add al, 0x11 ; mov eax, 0xffffffff ; pop ebx ; pop esi ; ret
0x080508ca : add al, 0x11 ; mov eax, 0xffffffff ; pop ebx ; ret
0x0807a779 : add al, 0x13 ; pop ebx ; pop esi ; ret
0x080b3429 : add al, 0x24 ; add esp, 0xc ; pop ebx ; pop esi ; ret
0x080b33bd : add al, 0x24 ; add esp, 4 ; ret
0x080b33ba : add al, 0x24 ; fld dword ptr [esp] ; add esp, 4 ; ret
0x0809b63c : add al, 0x24 ; mov eax, dword ptr [esp + 4] ; ret 0x14
0x0809b5f5 : add al, 0x24 ; mov eax, dword ptr [esp + 4] ; ret 0xc
0x080b9a2e : add al, 0x24 ; ret
0x080dac6c : add al, 0x25 ; add byte ptr [eax], al ; adc byte ptr [esi - 9], bh ; call ebx
0x080a65df : add al, 0x29 ; ret
0x08056eaa : add al, 0x29 ; ret 0x30a3
0x0805292d : add al, 0x29 ; ret 0x5052
0x0809bf0b : add al, 0x29 ; ret 0x5389
0x080973c0 : add al, 0x29 ; ret 0x5689
0x0809727a : add al, 0x29 ; ret 0xd089
0x08054a92 : add al, 0x29 ; ret 0xd189
0x08050030 : add al, 0x29 ; ret 0xfac1
0x080493dc : add al, 0x2b ; inc ebx ; add al, 0x83 ; les eax, ptr [ebx + ebx*2] ; pop esi ; ret
0x08096396 : add al, 0x31 ; rcr byte ptr [ebx + 0x5e], 0x5f ; ret
0x08054626 : add al, 0x39 ; fidiv dword ptr [ebx + 0x1d] ; movzx eax, byte ptr [edx] ; pop ebx ; ret
0x080849b0 : add al, 0x39 ; ret
0x0805ea9b : add al, 0x39 ; ret 0x1d72
0x0805cabb : add al, 0x39 ; ret 0x1e72
0x0808b380 : add al, 0x39 ; ret 0xf375
0x080e68ce : add al, 0x41 ; or eax, dword ptr [ebx + 0xa] ; push cs ; adc al, 0x46 ; ret
0x080e403b : add al, 0x41 ; or eax, dword ptr [ebx + 0xa] ; ret
0x080e68fa : add al, 0x41 ; or eax, dword ptr [ebx + 0xe] ; adc al, 0x46 ; ret
0x080e76b9 : add al, 0x41 ; or eax, dword ptr [ebx] ; push cs ; add dword ptr [edx], ecx ; ret
0x080e5949 : add al, 0x41 ; or eax, dword ptr [edx] ; inc esi ; or cl, byte ptr [esi] ; adc al, 0x43 ; ret
0x080dcb01 : add al, 0x41 ; or eax, dword ptr [edx] ; lahf ; or cl, byte ptr [esi] ; adc al, 0x46 ; ret
0x080dc1b5 : add al, 0x41 ; or eax, dword ptr [edx] ; loop 0x80dc1ce ; push cs ; adc al, 0x43 ; ret
0x080e374e : add al, 0x41 ; or eax, dword ptr [edx] ; out dx, eax ; or cl, byte ptr [esi] ; adc al, 0x41 ; ret
0x080e495f : add al, 0x41 ; or eax, dword ptr [edx] ; xchg eax, ecx ; push cs ; adc al, 0x41 ; ret
0x080e36bb : add al, 0x41 ; or eax, dword ptr [esi + 0xa] ; push cs ; adc al, 0x43 ; ret
0x080e7e91 : add al, 0x41 ; or eax, dword ptr [esi + 0xa] ; push cs ; adc al, 0x46 ; ret
0x080e4042 : add al, 0x41 ; or eax, dword ptr [esi + 0xa] ; ret
0x080ea879 : add al, 0x41 ; or eax, dword ptr [esi + 0xe] ; adc al, 0x43 ; ret
0x080dbe04 : add al, 0x41 ; or ebp, dword ptr [ecx + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080ea6ff : add al, 0x41 ; or ebp, dword ptr [esi + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080d9cce : add al, 0x41 ; or ebx, dword ptr [ebx + 0xa] ; push cs ; or al, 0x46 ; ret
0x080e827d : add al, 0x41 ; or ebx, dword ptr [edi + 0xa] ; ret
0x080e6f9b : add al, 0x41 ; or ecx, dword ptr [ebp + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080e2408 : add al, 0x41 ; or ecx, dword ptr [ebx + 0xe] ; adc al, 0x46 ; ret
0x080dfdf1 : add al, 0x41 ; or ecx, dword ptr [edx + 0xa] ; push cs ; adc al, 0x43 ; ret
0x080d9238 : add al, 0x41 ; or edx, dword ptr [ebx + 0xa] ; push cs ; adc al, 0x43 ; ret
0x080e0a85 : add al, 0x41 ; or edx, dword ptr [ecx + 0xa] ; push cs ; adc al, 0x46 ; ret
0x080e8651 : add al, 0x41 ; or edx, dword ptr [edi + 0xe] ; or al, 0x41 ; ret
0x080de54a : add al, 0x41 ; or edx, dword ptr [edx + ecx + 0xe] ; adc al, 0x43 ; ret
0x080e5550 : add al, 0x41 ; or edx, dword ptr [esi + 0xa] ; push cs ; adc al, 0x43 ; ret
0x080e7df1 : add al, 0x41 ; or edx, dword ptr [esi + 0xe] ; adc al, 0x41 ; ret
0x080de1ec : add al, 0x41 ; or esp, dword ptr [ebp + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080e3f85 : add al, 0x41 ; or esp, dword ptr [ebx + 0xa] ; push cs ; adc al, 0x43 ; ret
0x080e4c84 : add al, 0x41 ; or esp, dword ptr [ecx + 0xe] ; adc al, 0x41 ; ret
0x080e61fb : add al, 0x42 ; or eax, dword ptr [ebx + 0xa] ; push cs ; or al, 0x43 ; ret
0x080e6cc6 : add al, 0x42 ; or eax, dword ptr [ebx + 0xe] ; or al, 0x43 ; ret
0x080e842e : add al, 0x42 ; or eax, dword ptr [edx] ; push edi ; or cl, byte ptr [esi] ; adc al, 0x43 ; ret
0x080e6fc9 : add al, 0x42 ; or eax, dword ptr [edx] ; xlatb ; or cl, byte ptr [esi] ; adc al, 0x41 ; ret
0x080e1157 : add al, 0x42 ; or ebx, dword ptr [ecx + 0xa] ; push cs ; adc al, 0x43 ; ret
0x080e1e01 : add al, 0x42 ; or ebx, dword ptr [ecx + 0xa] ; ret
0x080e8635 : add al, 0x42 ; or ecx, dword ptr [edi + 0xa] ; push cs ; or al, 0x41 ; ret
0x080e264d : add al, 0x42 ; or edx, dword ptr [ecx + 0xa] ; ret
0x080db83a : add al, 0x42 ; or esi, dword ptr [edx + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080e1ad9 : add al, 0x42 ; or esp, dword ptr [eax + 0xa] ; push cs ; adc al, 0x43 ; ret
0x080dba88 : add al, 0x43 ; or eax, dword ptr [ebp + 0xa] ; push cs ; adc al, 0x43 ; ret
0x080dc879 : add al, 0x43 ; or eax, dword ptr [ebx + 0xa] ; push cs ; adc al, 0x43 ; ret
0x080db7c0 : add al, 0x43 ; or eax, dword ptr [ebx + 0xa] ; push cs ; adc al, 0x45 ; ret
0x080e4187 : add al, 0x43 ; or eax, dword ptr [ebx + 0xa] ; ret
0x080e2f38 : add al, 0x43 ; or eax, dword ptr [ebx + 0xe] ; adc al, 0x43 ; ret
0x080e693c : add al, 0x43 ; or eax, dword ptr [ebx] ; add dword ptr [edx], ecx ; ret
0x080df941 : add al, 0x43 ; or eax, dword ptr [edx] ; jns 0x80df957 ; ret
0x080e433b : add al, 0x43 ; or eax, dword ptr [edx] ; push ebp ; push cs ; adc al, 0x41 ; ret
0x080e75f0 : add al, 0x43 ; or ebx, dword ptr [edi + 0xa] ; push cs ; adc al, 0x46 ; ret
0x080e3d0c : add al, 0x43 ; or ecx, dword ptr [eax + 0xa] ; ret
0x080da98c : add al, 0x43 ; or ecx, dword ptr [edx + 0xe] ; adc al, 0x43 ; ret
0x080de82c : add al, 0x44 ; or eax, dword ptr [edx] ; dec ebx ; or cl, byte ptr [esi] ; adc al, 0x41 ; ret
0x080e16d5 : add al, 0x44 ; or eax, dword ptr [edx] ; inc eax ; push cs ; adc al, 0x46 ; ret
0x080e265b : add al, 0x44 ; or eax, dword ptr [edx] ; jl 0x80e2671 ; ret
0x080d973a : add al, 0x44 ; or eax, dword ptr [edx] ; push ebp ; or cl, byte ptr [esi] ; adc al, 0x43 ; ret
0x080d8b4c : add al, 0x44 ; or eax, dword ptr [edx] ; push ebx ; or cl, byte ptr [esi] ; adc al, 0x43 ; ret
0x080e3270 : add al, 0x44 ; or eax, dword ptr [edx] ; push esi ; ret
0x080da7cc : add al, 0x44 ; or ebp, dword ptr [eax + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080e68b8 : add al, 0x44 ; or ebp, dword ptr [edx + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080e0b5a : add al, 0x44 ; or ebx, dword ptr [ebp + 0xe] ; adc al, 0x41 ; ret
0x080eb10a : add al, 0x44 ; or ebx, dword ptr [ebx + 0xa] ; push cs ; adc al, 0x43 ; ret
0x080e4dec : add al, 0x44 ; or ebx, dword ptr [ecx + 0xa] ; ret
0x080e0edb : add al, 0x44 ; or ebx, dword ptr [edx + 0xa] ; push cs ; adc al, 0x43 ; ret
0x080e5065 : add al, 0x44 ; or esi, dword ptr [edi + 0xa] ; ret
0x080e686f : add al, 0x44 ; ret
0x080dc863 : add al, 0x45 ; or eax, dword ptr [ebx + 0xa] ; push cs ; adc al, 0x44 ; ret
0x080e418e : add al, 0x45 ; or eax, dword ptr [ebx + 0xa] ; ret
0x080e60b2 : add al, 0x45 ; or eax, dword ptr [ebx + 0xe] ; or al, 0x43 ; ret
0x080ea5d5 : add al, 0x45 ; or eax, dword ptr [esi + 0xa] ; push cs ; adc al, 0x46 ; ret
0x080ea694 : add al, 0x45 ; or eax, dword ptr [esi + 0xe] ; adc al, 0x43 ; ret
0x080e1903 : add al, 0x45 ; or ebp, dword ptr [esi + 0xe] ; adc al, 0x46 ; ret
0x080ea8d2 : add al, 0x45 ; or ecx, dword ptr [edi + 0xa] ; ret
0x080e761c : add al, 0x45 ; or edx, dword ptr [eax + 0xe] ; adc al, 0x41 ; ret
0x080d9df3 : add al, 0x45 ; or edx, dword ptr [ecx + 0xa] ; push cs ; or al, 0x41 ; ret
0x080e5f0a : add al, 0x45 ; or edx, dword ptr [esi + ecx + 0xc] ; inc ebx ; ret
0x080e6744 : add al, 0x45 ; or esi, dword ptr [edx + 0xa] ; push cs ; adc al, 0x46 ; ret
0x080d9e9f : add al, 0x45 ; or esp, dword ptr [eax + 0xa] ; ret
0x080e37bc : add al, 0x45 ; or esp, dword ptr [ecx + 0xe] ; adc al, 0x43 ; ret
0x080e4adf : add al, 0x45 ; or esp, dword ptr [ecx + 0xe] ; or al, 0x43 ; ret
0x080e56a5 : add al, 0x46 ; or cl, byte ptr [esi] ; adc al, 0x41 ; ret
0x080deca6 : add al, 0x46 ; or eax, dword ptr [ebx + 0xa] ; push cs ; adc al, 0x43 ; ret
0x080da28d : add al, 0x46 ; or eax, dword ptr [edi + 0xa] ; ret
0x080d8d4f : add al, 0x46 ; or eax, dword ptr [edx] ; inc ebx ; or cl, byte ptr [esi] ; adc al, 0x43 ; ret
0x080e149b : add al, 0x46 ; or eax, dword ptr [edx] ; mov dh, 0xa ; ret
0x080e1a89 : add al, 0x46 ; or eax, dword ptr [edx] ; pushal ; ret
0x080e49d5 : add al, 0x46 ; or eax, dword ptr [edx] ; ret
0x080e1eb1 : add al, 0x46 ; or eax, dword ptr [esi + 0xa] ; ret
0x080e7cac : add al, 0x46 ; or ebp, dword ptr [ecx + 0xa] ; push cs ; adc al, 0x43 ; ret
0x080ea410 : add al, 0x46 ; or ebp, dword ptr [edi + 0xa] ; push cs ; adc al, 0x46 ; ret
0x080eae26 : add al, 0x46 ; or ebx, dword ptr [ebx + 0xe] ; adc al, 0x46 ; ret
0x080e252b : add al, 0x46 ; or ecx, dword ptr [ebx + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080ea6e9 : add al, 0x46 ; or edi, dword ptr [ecx + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080d9878 : add al, 0x46 ; or edx, dword ptr [ebp + 0xa] ; ret
0x080dbe6e : add al, 0x46 ; or edx, dword ptr [ebx + 0xa] ; push cs ; adc al, 0x43 ; ret
0x080db489 : add al, 0x46 ; or edx, dword ptr [ecx + 0xa] ; push cs ; or al, 0x41 ; ret
0x080e74e6 : add al, 0x46 ; or edx, dword ptr [edx + 0xa] ; ret
0x080e1334 : add al, 0x46 ; or esi, dword ptr [eax + 0xa] ; ret
0x080d9d96 : add al, 0x46 ; or esp, dword ptr [ebx + 0xe] ; adc al, 0x43 ; ret
0x080e4f57 : add al, 0x47 ; or eax, dword ptr [ebx + 0xe] ; adc al, 0x43 ; ret
0x080dfbf9 : add al, 0x47 ; or eax, dword ptr [ebx + 0xe] ; or al, 0x46 ; ret
0x080e25d0 : add al, 0x47 ; or eax, dword ptr [edx] ; dec edx ; ret
0x080e271d : add al, 0x47 ; or eax, dword ptr [edx] ; dec esi ; push cs ; adc al, 0x46 ; ret
0x080dc2b0 : add al, 0x47 ; or eax, dword ptr [edx] ; insb byte ptr es:[edi], dx ; push cs ; adc al, 0x44 ; ret
0x080dab07 : add al, 0x47 ; or eax, dword ptr [edx] ; xlatb ; or cl, byte ptr [esi] ; adc al, 0x41 ; ret
0x080e7733 : add al, 0x47 ; or ebp, dword ptr [ebp + 0xa] ; ret
0x080e0d22 : add al, 0x47 ; or ebx, dword ptr [esi + ecx + 0x10] ; inc ecx ; ret
0x080e5052 : add al, 0x47 ; or ecx, dword ptr [ecx + 0xa] ; ret
0x080e8643 : add al, 0x47 ; or edx, dword ptr [ebp + 0xa] ; push cs ; or al, 0x41 ; ret
0x080db824 : add al, 0x47 ; or edx, dword ptr [edx + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080e4d2c : add al, 0x47 ; or edx, dword ptr [esi + 0xa] ; push cs ; or al, 0x43 ; ret
0x080eacfb : add al, 0x48 ; or eax, dword ptr [ebx + 0xe] ; adc al, 0x43 ; ret
0x080df89a : add al, 0x48 ; or eax, dword ptr [ebx + 0xe] ; or al, 0x41 ; ret
0x080e1ea1 : add al, 0x48 ; or eax, dword ptr [ebx] ; lsl ecx, dword ptr [edx] ; ret
0x080dffd8 : add al, 0x48 ; or eax, dword ptr [edx] ; jnp 0x80dfff1 ; push cs ; adc al, 0x43 ; ret
0x080e148c : add al, 0x48 ; or eax, dword ptr [edx] ; mov bh, 0xa ; ret
0x080e2a3d : add al, 0x48 ; or eax, dword ptr [esi + 0xa] ; ret
0x080e7606 : add al, 0x48 ; or ebp, dword ptr [edi + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080dc41e : add al, 0x48 ; or ebp, dword ptr [esi + 0xa] ; push cs ; adc al, 0x43 ; ret
0x080e23ad : add al, 0x48 ; or ebx, dword ptr [ecx + 0xa] ; ret
0x080eb2c7 : add al, 0x48 ; or ecx, dword ptr [edx + 0xa] ; push cs ; adc al, 0x46 ; ret
0x080e298f : add al, 0x48 ; or edi, dword ptr [edi + 0xa] ; ret
0x080e2a2c : add al, 0x48 ; or edx, dword ptr [ebp + 0x2e] ; adc byte ptr [eax + 0xa], ch ; ret
0x080e7be1 : add al, 0x48 ; or edx, dword ptr [edx + ecx + 0xe] ; or al, 0x43 ; ret
0x080e153c : add al, 0x49 ; or eax, dword ptr [ebx] ; dec ecx ; add ecx, dword ptr [edx] ; ret
0x080dc302 : add al, 0x49 ; or eax, dword ptr [edx] ; dec edi ; or cl, byte ptr [esi] ; or al, 0x41 ; ret
0x080e258f : add al, 0x49 ; or eax, dword ptr [edx] ; mov byte ptr [edx], cl ; ret
0x080d9913 : add al, 0x49 ; or ebp, dword ptr [ebp + 0xa] ; ret
0x080de843 : add al, 0x49 ; or ebx, dword ptr [ecx + 0xa] ; push cs ; adc al, 0x43 ; ret
0x080e758a : add al, 0x49 ; or ecx, dword ptr [edx + 0xa] ; ret
0x080e321d : add al, 0x49 ; or edx, dword ptr [edx + ecx + 0xe] ; or al, 0x41 ; ret
0x080d9ca9 : add al, 0x4a ; or eax, dword ptr [ebp + 0xa] ; push cs ; or al, 0x41 ; ret
0x080de474 : add al, 0x4a ; or eax, dword ptr [ebx + 0xa] ; push cs ; or al, 0x46 ; ret
0x080db06f : add al, 0x4b ; or eax, dword ptr [ebx + 0xe] ; adc al, 0x43 ; ret
0x080e7778 : add al, 0x4b ; or ebp, dword ptr [ebp + 0xa] ; ret
0x080e4221 : add al, 0x4b ; or ebx, dword ptr [ebx + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080e309a : add al, 0x4b ; or ecx, dword ptr [edx + 0xe] ; or al, 0x41 ; ret
0x080e2a80 : add al, 0x4b ; or edx, dword ptr [eax + 0xa] ; ret
0x080df1ac : add al, 0x4b ; or edx, dword ptr [edi + 0xa] ; ret
0x080dcb6c : add al, 0x4c ; or edx, dword ptr [esi + 0xa] ; ret
0x080dca6c : add al, 0x4d ; or ecx, dword ptr [esi + ecx + 8] ; inc ecx ; ret
0x080e564b : add al, 0x4e ; or cl, byte ptr [esi] ; adc al, 0x43 ; ret
0x080dbfd2 : add al, 0x4f ; or eax, dword ptr [ecx + 0xa] ; ret
0x080dc311 : add al, 0x4f ; or edx, dword ptr [esi + 0xa] ; push cs ; or al, 0x43 ; ret
0x0804f5f3 : add al, 0x50 ; push edx ; push ebp ; call ebx
0x0805117a : add al, 0x50 ; push edx ; push ebp ; call ecx
0x0806de09 : add al, 0x51 ; push 3 ; push ebx ; call esi
0x08058f02 : add al, 0x51 ; push esi ; push eax ; call edx
0x0807af9e : add al, 0x55 ; push dword ptr [esp + 0x28] ; push esi ; call edi
0x0807ac46 : add al, 0x55 ; push ebx ; push esi ; call edi
0x0807ac22 : add al, 0x55 ; push esi ; push dword ptr [esp + 0x1c] ; call edi
0x0807abee : add al, 0x55 ; push esi ; push dword ptr [esp + 0x28] ; call edi
0x0807c7e9 : add al, 0x56 ; push edi ; push dword ptr [ebp - 0x50] ; call eax
0x08098852 : add al, 0x56 ; push edx ; push eax ; call ebx
0x0806ddb2 : add al, 0x57 ; push 0 ; push ebx ; call esi
0x0806ddcf : add al, 0x57 ; push 1 ; push ebx ; call esi
0x0806ddec : add al, 0x57 ; push 2 ; push ebx ; call esi
0x0808b2e5 : add al, 0x5b ; pop esi ; jmp eax
0x08054f5d : add al, 0x5b ; pop esi ; pop edi ; pop ebp ; ret
0x080a5db1 : add al, 0x5b ; pop esi ; pop edi ; ret
0x080493e2 : add al, 0x5b ; pop esi ; ret
0x08053175 : add al, 0x5b ; ret
0x080e5619 : add al, 0x5c ; or cl, byte ptr [esi] ; adc al, 0x41 ; ret
0x080b625b : add al, 0x5d ; ret
0x080b6262 : add al, 0x5e ; pop edi ; pop ebp ; xor eax, eax ; ret
0x080a5cf7 : add al, 0x5e ; pop edi ; ret
0x080668ec : add al, 0x5f ; ret
0x0809c182 : add al, 0x65 ; sub eax, dword ptr [0] ; ret
0x080668f7 : add al, 0x66 ; mov dword ptr [edx + 4], eax ; lea eax, dword ptr [edx + 5] ; pop edi ; ret
0x08066a37 : add al, 0x66 ; mov dword ptr [edx + 4], eax ; lea eax, dword ptr [edx + 5] ; ret
0x08065097 : add al, 0x66 ; mov dword ptr [edx + 4], eax ; mov eax, edi ; pop edi ; ret
0x080651c7 : add al, 0x66 ; mov dword ptr [edx + 4], eax ; mov eax, edx ; ret
0x080da5ef : add al, 0x66 ; ret
0x0809aea0 : add al, 0x68 ; call dword ptr [edx]
0x080df0bb : add al, 0x6b ; ret
0x080953ba : add al, 0x6b ; ret 0x291d
0x0806ee1e : add al, 0x74 ; pop ss ; pop ebx ; pop esi ; pop edi ; ret
0x0808dd87 : add al, 0x75 ; add ecx, dword ptr [ecx + 0x5e5b084a] ; ret
0x080b691b : add al, 0x76 ; ret
0x080e5f79 : add al, 0x83 ; add eax, 0xa011403 ; ret
0x080e81ed : add al, 0x83 ; add eax, 0xa011903 ; ret
0x080e1849 : add al, 0x83 ; add eax, 0xa013603 ; ret
0x080dee95 : add al, 0x83 ; add eax, 0xa013a03 ; ret
0x080e5ac9 : add al, 0x83 ; add eax, 0xa013c03 ; ret
0x080da27d : add al, 0x83 ; add eax, 0xa013e03 ; ret
0x080d8c61 : add al, 0x83 ; add eax, 0xa014503 ; ret
0x080df675 : add al, 0x83 ; add eax, 0xa016103 ; ret
0x080e1e31 : add al, 0x83 ; add eax, 0xa016903 ; ret
0x080e1c5d : add al, 0x83 ; add eax, 0xa018203 ; ret
0x080da0b5 : add al, 0x83 ; add eax, 0xa019f03 ; ret
0x080e1c8d : add al, 0x83 ; add eax, 0xa01ad03 ; ret
0x080d94e1 : add al, 0x83 ; add eax, 0xa01b603 ; ret
0x080e5209 : add al, 0x83 ; add eax, 0xa01e603 ; ret
0x080e51c9 : add al, 0x83 ; add eax, 0xa01ef03 ; ret
0x080d9a4d : add al, 0x83 ; add eax, 0xa020f03 ; ret
0x080dfcbd : add al, 0x83 ; add eax, 0xa023e03 ; ret
0x080e825d : add al, 0x83 ; add eax, 0xa023f03 ; ret
0x080e82ed : add al, 0x83 ; add eax, 0xa029403 ; ret
0x080e76a9 : add al, 0x83 ; add eax, 0xa02b703 ; ret
0x080d8f19 : add al, 0x83 ; add eax, 0xa02e503 ; ret
0x080e66ed : add al, 0x83 ; add eax, 0xa030903 ; ret
0x080d8ca1 : add al, 0x83 ; add eax, 0xa035d03 ; ret
0x080e1e91 : add al, 0x83 ; add eax, 0xa03d103 ; ret
0x080e5d55 : add al, 0x83 ; add eax, 0xa043003 ; ret
0x080e5d85 : add al, 0x83 ; add eax, 0xa059903 ; ret
0x080df931 : add al, 0x83 ; add eax, 0xa075b03 ; ret
0x080e7fc5 : add al, 0x83 ; add eax, 0xa09eb03 ; ret
0x080493df : add al, 0x83 ; les eax, ptr [ebx + ebx*2] ; pop esi ; ret
0x0806be25 : add al, 0x83 ; les ebx, ptr [ebx + ebx*2] ; pop esi ; pop edi ; pop ebp ; ret
0x080b9c82 : add al, 0x83 ; les ecx, ptr [eax] ; pop ebx ; ret
0x08055c42 : add al, 0x83 ; les ecx, ptr [ebx + ebx*2] ; pop esi ; pop edi ; pop ebp ; ret
0x08073af3 : add al, 0x83 ; les edi, ptr [ebx + ebx*2] ; pop esi ; pop edi ; pop ebp ; ret
0x0805facd : add al, 0x83 ; ljmp -0x8fe:0x89068b04 ; ret 0xf
0x0805e9fd : add al, 0x83 ; ljmp -0x8fe:0x89078b04 ; ret 0xf
0x0805961a : add al, 0x83 ; ljmp 0x450f:0x1e08304 ; ret 0xc483
0x0808c20c : add al, 0x83 ; out dx, al ; add al, 0x83 ; out dx, al ; add al, 0xf7 ; ret 0
0x0808c20f : add al, 0x83 ; out dx, al ; add al, 0xf7 ; ret 0
0x08059a84 : add al, 0x83 ; ret
0x0807c7d4 : add al, 0x83 ; ret 0x390c
0x0804f0dd : add al, 0x83 ; ret 0x512c
0x0805beb2 : add al, 0x83 ; ret 0x8304
0x080984fc : add al, 0x83 ; ret 0x8508
0x0807392f : add al, 0x83 ; ret 0x8b01
0x0805bec1 : add al, 0x83 ; ret 0x8b04
0x080700fa : add al, 0x83 ; ret 0xf610
0x0804c3c3 : add al, 0x83 ; rol byte ptr [ecx], 0x83 ; ret 0x5201
0x0807eebf : add al, 0x85 ; add al, ah ; or al, 8 ; jmp eax
0x0807ed8d : add al, 0x85 ; add bh, bl ; or al, 8 ; jmp eax
0x0807fa4e : add al, 0x85 ; add cl, ah ; or al, 8 ; jmp eax
0x080b6083 : add al, 0x85 ; inc eax ; sub byte ptr [eax + ecx], cl ; sub eax, ecx ; pop ebp ; ret
0x0806ae16 : add al, 0x85 ; inc eax ; sub byte ptr [eax + ecx], cl ; sub eax, ecx ; ret
0x08099131 : add al, 0x85 ; leave ; jne 0x8099116 ; pop ebx ; ret
0x080876d5 : add al, 0x85 ; loopne 0x80876c3 ; or al, 8 ; jmp eax
0x08087715 : add al, 0x85 ; loopne 0x8087703 ; or al, 8 ; jmp eax
0x08088142 : add al, 0x85 ; loopne 0x8088132 ; or al, 8 ; jmp eax
0x08088180 : add al, 0x85 ; loopne 0x8088170 ; or al, 8 ; jmp eax
0x080881c8 : add al, 0x85 ; loopne 0x80881b8 ; or al, 8 ; jmp eax
0x08088206 : add al, 0x85 ; loopne 0x80881f6 ; or al, 8 ; jmp eax
0x08088590 : add al, 0x85 ; loopne 0x808857e ; or al, 8 ; jmp eax
0x08088a84 : add al, 0x85 ; loopne 0x8088a74 ; or al, 8 ; jmp eax
0x08088ac2 : add al, 0x85 ; loopne 0x8088ab2 ; or al, 8 ; jmp eax
0x08071ade : add al, 0x85 ; ror byte ptr [edi], 0x44 ; ret
0x08097af4 : add al, 0x85 ; ror byte ptr [edi], 0x44 ; ret 0x6850
0x0808e428 : add al, 0x85 ; sal byte ptr [ebp - 0xd], cl ; ret
0x0809cd10 : add al, 0x87 ; lea esp, dword ptr [ebp - 0xc] ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x08065086 : add al, 0x88 ; inc edx ; add al, 0x89 ; clc ; pop edi ; ret
0x080668e6 : add al, 0x88 ; inc edx ; add al, 0x8d ; inc edx ; add al, 0x5f ; ret
0x08065089 : add al, 0x89 ; clc ; pop edi ; ret
0x0804ff91 : add al, 0x89 ; dec eax ; adc byte ptr [ecx - 0x9ec74ce], cl ; ret 0x7402
0x0806dbb8 : add al, 0x89 ; fcomp dword ptr [ebx + 0x5e] ; ret
0x0804d763 : add al, 0x89 ; inc ebp ; add bl, ch ; ret 0x7c89
0x080515a8 : add al, 0x89 ; inc ebx ; or byte ptr [ecx], dh ; rcr byte ptr [ebx + 0x5e], 0x5f ; ret
0x08066e07 : add al, 0x89 ; inc edx ; add al, 0x89 ; clc ; pop edi ; ret
0x080673f7 : add al, 0x89 ; inc edx ; add al, 0x8d ; inc edx ; pop es ; pop edi ; ret
0x08067646 : add al, 0x89 ; inc edx ; add al, 0x8d ; inc edx ; pop es ; ret
0x080b94b7 : add al, 0x89 ; push eax ; dec esp ; ret
0x0804f67a : add al, 0x89 ; ret
0x0806bf66 : add al, 0x89 ; ret 0x850f
0x08098088 : add al, 0x89 ; ret 0xc031
0x08056d63 : add al, 0x89 ; ret 0xdaf7
0x0804ddd2 : add al, 0x89 ; ret 0xe2c1
0x0809c507 : add al, 0x89 ; ret 0xf8c1
0x0809b082 : add al, 0x89 ; stc ; add edx, eax ; jmp 0x809b09b
0x08067049 : add al, 0x8a ; inc ecx ; or byte ptr [eax - 0x2f76f7be], cl ; ret
0x08092a98 : add al, 0x8b ; add edi, dword ptr [ecx] ; ret 0x870f
0x080973ba : add al, 0x8b ; dec ebp ; mov al, 3 ; push ecx ; add al, 0x29 ; ret 0x5689
0x080b9403 : add al, 0x8b ; inc eax ; dec eax ; ret
0x080b9483 : add al, 0x8b ; inc eax ; dec esp ; ret
0x08055ac2 : add al, 0x8b ; inc eax ; or al, 0x83 ; ret
0x080b9523 : add al, 0x8b ; inc eax ; pop eax ; ret
0x080b94d3 : add al, 0x8b ; inc eax ; pop esp ; ret
0x080b94c3 : add al, 0x8b ; inc eax ; push eax ; ret
0x080b9533 : add al, 0x8b ; inc eax ; push esp ; ret
0x080670a9 : add al, 0x8b ; inc ecx ; or byte ptr [ecx - 0x2f76f7be], cl ; ret
0x08067089 : add al, 0x8b ; inc ecx ; pop es ; mov dword ptr [edx + 7], eax ; mov eax, edx ; ret
0x0807a792 : add al, 0x8b ; inc esp ; nop ; inc eax ; ret
0x0808a7cf : add al, 0x8b ; pop esi ; or byte ptr [ecx], ch ; ret
0x08081f41 : add al, 0x8b ; push ebp ; aam 0x83 ; call 0x17ca5855
0x08079c93 : add al, 0x8b ; push esp ; and al, 8 ; mov eax, dword ptr [eax] ; sub eax, dword ptr [edx] ; ret
0x080668e9 : add al, 0x8d ; inc edx ; add al, 0x5f ; ret
0x080673fa : add al, 0x8d ; inc edx ; pop es ; pop edi ; ret
0x08067649 : add al, 0x8d ; inc edx ; pop es ; ret
0x0808050d : add al, 0x91 ; mov eax, esi ; pop ebx ; pop esi ; pop edi ; ret
0x0808e3e6 : add al, 0x93 ; test eax, eax ; jne 0x808e3b9 ; mov eax, edx ; pop ebx ; ret
0x0809d09d : add al, 0x9e ; add esp, 0x2c ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x080915a0 : add al, 0xa ; pop ebx ; pop esi ; ret
0x080e880f : add al, 0xa ; push cs ; adc al, 0x41 ; ret
0x080e5d5a : add al, 0xa ; ret
0x080b39e9 : add al, 0xab ; je 0x80b39d0 ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x080b7031 : add al, 0xab ; je 0x80b7018 ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x08068a7c : add al, 0xb3 ; je 0x8068a67 ; pop ebx ; pop esi ; pop edi ; ret
0x0808dcb4 : add al, 0xb3 ; je 0x808dc9f ; pop ebx ; pop esi ; pop edi ; ret
0x0806c582 : add al, 0xb8 ; add dword ptr [eax], eax ; add byte ptr [eax], al ; pop ebx ; pop esi ; ret
0x0809c413 : add al, 0xb8 ; push eax ; ret
0x0804f6ab : add al, 0xc1 ; sti ; add cl, byte ptr [edi] ; scasd eax, dword ptr es:[edi] ; ret
0x0806af6b : add al, 0xc3 ; xor eax, eax ; ret
0x080b3486 : add al, 0xdb ; sub al, 0x24 ; add esp, 0x1c ; ret
0x080b3427 : add al, 0xdd ; add al, 0x24 ; add esp, 0xc ; pop ebx ; pop esi ; ret
0x080e6b6c : add al, 0xe4 ; add byte ptr [eax], al ; push ebp ; push esi ; sti ; jmp dword ptr [eax]
0x080a8d32 : add al, 0xe8 ; pop eax ; and bh, bl ; inc dword ptr [ecx] ; ret
0x08094e97 : add al, 0xe8 ; ret
0x0809b4c8 : add al, 0xe8 ; ret 0xfbda
0x08053415 : add al, 0xf ; mov dh, 0 ; add esp, 8 ; pop ebx ; ret
0x0808c212 : add al, 0xf7 ; ret 0
0x080b9687 : add al, 0xff ; aaa ; push 1 ; push 1 ; call eax
0x080b90af : add al, 0xff ; aaa ; push ecx ; push 1 ; call eax
0x080591aa : add al, 0xff ; je 0x80591d9 ; xor byte ptr [esi + 0x53], dl ; call eax
0x080b917e : add al, 0xff ; xor ebp, dword ptr [edx + 0xa] ; push 1 ; call eax
0x080a9099 : add al, 1 ; ret
0x08096c14 : add al, 1 ; ret 0xb989
0x0808dd74 : add al, 1 ; ret 0xf685
0x0806c67d : add al, 1 ; ror byte ptr [ecx + 0x29102444], 1 ; ret
0x08090cbd : add al, 2 ; add al, byte ptr [eax] ; add byte ptr [eax], al ; xor eax, eax ; ret
0x080e278b : add al, 2 ; dec ecx ; ret
0x080e24df : add al, 2 ; inc edi ; ret
0x080e5c2f : add al, 2 ; ja 0x80e5c41 ; ret
0x080dd6ef : add al, 2 ; lodsb al, byte ptr [esi] ; ret
0x08057ded : add al, 2 ; or al, 0 ; add byte ptr [eax], al ; xor eax, eax ; ret
0x080e7f6b : add al, 2 ; pop edx ; ret
0x080e7725 : add al, 2 ; push eax ; and byte ptr cs:[edx + 0xa], ah ; ret
0x080d9905 : add al, 2 ; push ebx ; adc byte ptr cs:[ebp + 0xa], bl ; ret
0x080e283b : add al, 2 ; push edx ; ret
0x080a8312 : add al, 3 ; pop es ; push dword ptr [esp + 0x34] ; push esi ; push ebx ; call eax
0x080e1ea0 : add al, 4 ; dec eax ; or eax, dword ptr [ebx] ; lsl ecx, dword ptr [edx] ; ret
0x080e148b : add al, 4 ; dec eax ; or eax, dword ptr [edx] ; mov bh, 0xa ; ret
0x080e2a3c : add al, 4 ; dec eax ; or eax, dword ptr [esi + 0xa] ; ret
0x080e298e : add al, 4 ; dec eax ; or edi, dword ptr [edi + 0xa] ; ret
0x080e2a2b : add al, 4 ; dec eax ; or edx, dword ptr [ebp + 0x2e] ; adc byte ptr [eax + 0xa], ch ; ret
0x080e7777 : add al, 4 ; dec ebx ; or ebp, dword ptr [ebp + 0xa] ; ret
0x080e2a7f : add al, 4 ; dec ebx ; or edx, dword ptr [eax + 0xa] ; ret
0x080df1ab : add al, 4 ; dec ebx ; or edx, dword ptr [edi + 0xa] ; ret
0x080e153b : add al, 4 ; dec ecx ; or eax, dword ptr [ebx] ; dec ecx ; add ecx, dword ptr [edx] ; ret
0x080e258e : add al, 4 ; dec ecx ; or eax, dword ptr [edx] ; mov byte ptr [edx], cl ; ret
0x080d9912 : add al, 4 ; dec ecx ; or ebp, dword ptr [ebp + 0xa] ; ret
0x080ea8d1 : add al, 4 ; inc ebp ; or ecx, dword ptr [edi + 0xa] ; ret
0x080e693b : add al, 4 ; inc ebx ; or eax, dword ptr [ebx] ; add dword ptr [edx], ecx ; ret
0x080df940 : add al, 4 ; inc ebx ; or eax, dword ptr [edx] ; jns 0x80df958 ; ret
0x080e76b8 : add al, 4 ; inc ecx ; or eax, dword ptr [ebx] ; push cs ; add dword ptr [edx], ecx ; ret
0x080e827c : add al, 4 ; inc ecx ; or ebx, dword ptr [edi + 0xa] ; ret
0x080e25cf : add al, 4 ; inc edi ; or eax, dword ptr [edx] ; dec edx ; ret
0x080e7732 : add al, 4 ; inc edi ; or ebp, dword ptr [ebp + 0xa] ; ret
0x080e264c : add al, 4 ; inc edx ; or edx, dword ptr [ecx + 0xa] ; ret
0x080da28c : add al, 4 ; inc esi ; or eax, dword ptr [edi + 0xa] ; ret
0x080e149a : add al, 4 ; inc esi ; or eax, dword ptr [edx] ; mov dh, 0xa ; ret
0x080e1eb0 : add al, 4 ; inc esi ; or eax, dword ptr [esi + 0xa] ; ret
0x080d9877 : add al, 4 ; inc esi ; or edx, dword ptr [ebp + 0xa] ; ret
0x080e74e5 : add al, 4 ; inc esi ; or edx, dword ptr [edx + 0xa] ; ret
0x080e1333 : add al, 4 ; inc esi ; or esi, dword ptr [eax + 0xa] ; ret
0x080e265a : add al, 4 ; inc esp ; or eax, dword ptr [edx] ; jl 0x80e2672 ; ret
0x080e50ae : add al, 4 ; ret
0x080bc8c2 : add al, 8 ; ret
0x080e9d47 : add al, ah ; adc eax, 0x9aa40001 ; cld ; jmp dword ptr [eax]
0x08050982 : add al, ah ; into ; or ecx, dword ptr [eax] ; add esp, 8 ; pop ebx ; ret
0x080e6b47 : add al, ah ; jecxz 0x80e6b53 ; add byte ptr [ecx + 0x56], bl ; sti ; jmp dword ptr [eax]
0x080de01f : add al, ah ; movsb byte ptr es:[edi], byte ptr [esi] ; clc ; call dword ptr [ebx]
0x0807eec1 : add al, ah ; or al, 8 ; jmp eax
0x080e5d3f : add al, ah ; pop es ; sti ; call ebx
0x080e4c0f : add al, ah ; ret 0xfffa
0x080dc327 : add al, al ; cmp eax, dword ptr [eax] ; add byte ptr [esp + edi*4 - 9], ah ; call edi
0x080ded4f : add al, al ; idiv eax ; jmp dword ptr [edx]
0x080e5390 : add al, al ; or cl, byte ptr [esi] ; adc al, 0x41 ; ret
0x080cd37f : add al, al ; pop es ; add byte ptr [eax], al ; ret 7
0x080c942f : add al, al ; push cs ; add byte ptr [eax], al ; ret
0x080ddd27 : add al, al ; push ebp ; add byte ptr [eax], al ; and al, 0x9a ; clc ; call esp
0x080cd17f : add al, al ; push es ; add byte ptr [eax], al ; ret 6
0x080e06b7 : add al, bh ; pop edx ; stc ; jmp esp
0x080e195f : add al, bh ; xchg eax, ecx ; add byte ptr [eax], al ; in al, dx ; wait ; stc ; call dword ptr [ebx]
0x080e66d7 : add al, bl ; cmp bl, bh ; jmp eax
0x080e1467 : add al, bl ; cmp ecx, 0xff ; ret 3
0x080e2b3f : add al, bl ; mov dword ptr [0x7ffc0000], eax ; cli ; jmp dword ptr [edx]
0x08066a0e : add al, bl ; mov eax, dword ptr [ecx] ; mov dword ptr [edx], eax ; lea eax, dword ptr [edx + 3] ; ret
0x080e0120 : add al, byte ptr [eax + 0x41140e0a] ; ret
0x080ea5c1 : add al, byte ptr [eax + 0xa] ; push cs ; adc al, 0x46 ; ret
0x080db4fb : add al, byte ptr [eax + 0xa] ; ret
0x080e16d8 : add al, byte ptr [eax + 0xe] ; adc al, 0x46 ; ret
0x080e4b53 : add al, byte ptr [eax + eax] ; add al, dh ; ret
0x0808b189 : add al, byte ptr [eax] ; add al, ch ; call edi
0x0809daf0 : add al, byte ptr [eax] ; add byte ptr [eax], al ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x0808bbcc : add al, byte ptr [eax] ; add byte ptr [eax], al ; pop ebx ; pop esi ; pop edi ; ret
0x0808e3fc : add al, byte ptr [eax] ; add byte ptr [eax], al ; pop ebx ; ret
0x0809d9db : add al, byte ptr [eax] ; add byte ptr [eax], al ; pop esi ; pop edi ; pop ebp ; ret
0x0808e8f1 : add al, byte ptr [eax] ; add byte ptr [eax], al ; ret
0x08090cbf : add al, byte ptr [eax] ; add byte ptr [eax], al ; xor eax, eax ; ret
0x08071fa1 : add al, byte ptr [eax] ; add byte ptr [ebp - 0x7cffd98c], cl ; ret
0x0809405b : add al, byte ptr [eax] ; add byte ptr [ebx + 0x5e], bl ; pop edi ; pop ebp ; ret 0xc
0x08074697 : add al, byte ptr [eax] ; add byte ptr [ebx - 0x7ce3dbbc], cl ; ret 0xc704
0x080940c3 : add al, byte ptr [eax] ; add byte ptr [ecx + 0x5f5e5bf8], cl ; pop ebp ; ret 0xc
0x080a6024 : add al, byte ptr [eax] ; add byte ptr [ecx + 0x8c48302], cl ; pop ebx ; ret
0x08068253 : add al, byte ptr [eax] ; add byte ptr [ecx], al ; clc ; add eax, ecx ; pop edi ; ret
0x080cdb45 : add al, byte ptr [eax] ; add byte ptr [ecx], al ; or eax, 0x73950000 ; ret 0x48
0x0804e858 : add al, byte ptr [eax] ; add esp, 0x1c ; ret
0x080bc731 : add al, byte ptr [eax] ; add esp, 8 ; pop ebx ; ret
0x0804a922 : add al, byte ptr [eax] ; lea esp, dword ptr [ebp - 0xc] ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x08071012 : add al, byte ptr [eax] ; mov dword ptr [esp], ebx ; call esi
0x080716b1 : add al, byte ptr [eax] ; mov dword ptr [esp], ebx ; mov edx, dword ptr [ebp - 0x34] ; call edx
0x08071110 : add al, byte ptr [eax] ; mov dword ptr [esp], edi ; call ebx
0x08070392 : add al, byte ptr [eax] ; xor edx, edx ; cmp ebx, eax ; setne dl ; jmp 0x8070381
0x080d9d82 : add al, byte ptr [ebp + 0x41140e0a] ; ret
0x080da9b9 : add al, byte ptr [ebp + 0xe] ; adc byte ptr [esi + ecx + 8], ah ; inc ecx ; ret
0x0805425f : add al, byte ptr [ebp - 0xc0b8a40] ; ret
0x080dac90 : add al, byte ptr [ebx + 0x41140e0a] ; ret
0x0809c6f0 : add al, byte ptr [ebx + 0x5e5b01e8] ; ret
0x0808b676 : add al, byte ptr [ebx + 0x5e5b04c4] ; ret
0x080b9f8a : add al, byte ptr [ebx + 0x5e5b10c4] ; pop edi ; ret
0x0804fcc9 : add al, byte ptr [ebx + 0x5e5b14c4] ; ret
0x080da710 : add al, byte ptr [ebx + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080d8d52 : add al, byte ptr [ebx + 0xa] ; push cs ; adc al, 0x43 ; ret
0x080e9c40 : add al, byte ptr [ebx + 0xa] ; ret
0x080e7f1d : add al, byte ptr [ebx + 0xe] ; or al, 0x83 ; add ebx, dword ptr [ecx + 0xa] ; ret
0x0808dd6e : add al, byte ptr [ebx - 0x1d3efe3e] ; add al, 1 ; ret 0xf685
0x080e87f4 : add al, byte ptr [ebx] ; arpl word ptr [ecx], ax ; or cl, byte ptr [esi] ; adc al, 0x43 ; ret
0x080de41e : add al, byte ptr [ecx + 0xa] ; push cs ; or al, 0x41 ; ret
0x080e4de3 : add al, byte ptr [ecx + 0xa] ; ret
0x080e1b7d : add al, byte ptr [ecx + 0xe] ; or al, 0x83 ; add eax, dword ptr [edx] ; dec ecx ; ret
0x080e4f85 : add al, byte ptr [ecx + 0xe] ; or al, 0x83 ; add eax, dword ptr [edx] ; inc ecx ; ret
0x080e3cfd : add al, byte ptr [ecx + 0xe] ; or al, 0x83 ; add eax, dword ptr [edx] ; jp 0x80e3d19 ; ret
0x080e3db1 : add al, byte ptr [ecx + 0xe] ; or al, 0x83 ; add eax, dword ptr [edx] ; pop esp ; ret
0x080e1e59 : add al, byte ptr [ecx + 0xe] ; or al, 0x83 ; add ebp, dword ptr [esi + 0xa] ; ret
0x080e6f25 : add al, byte ptr [ecx + 0xe] ; or al, 0x83 ; add esi, dword ptr [ebx + 0xa] ; ret
0x080ea6d5 : add al, byte ptr [ecx] ; or cl, byte ptr [esi] ; adc al, 0x41 ; ret
0x080a49a5 : add al, byte ptr [ecx] ; ret
0x0807800f : add al, byte ptr [ecx] ; ret 0x153b
0x080da694 : add al, byte ptr [edi + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080eaeac : add al, byte ptr [edx + 0x41140e0a] ; ret
0x080e61ef : add al, byte ptr [edx + 0xa] ; push cs ; or al, 0x41 ; ret
0x080e1480 : add al, byte ptr [edx + 0xa] ; ret
0x080dfda5 : add al, byte ptr [edx + ecx + 0xe] ; adc al, 0x43 ; ret
0x080de9ee : add al, byte ptr [edx + ecx + 0xe] ; or al, 0x43 ; ret
0x080ea8e0 : add al, byte ptr [edx - 0x3c39383b] ; ret 0xcc0
0x080ea45c : add al, byte ptr [edx] ; cdq ; or cl, byte ptr [esi] ; adc al, 0x41 ; ret
0x080e8863 : add al, byte ptr [edx] ; dec esp ; or cl, byte ptr [esi] ; adc al, 0x41 ; ret
0x080e16c0 : add al, byte ptr [edx] ; fmul qword ptr [edx] ; push cs ; adc al, 0x41 ; ret
0x080ea525 : add al, byte ptr [edx] ; in eax, dx ; push cs ; adc al, 0x41 ; ret
0x080e1655 : add al, byte ptr [edx] ; inc eax ; ret
0x080ea864 : add al, byte ptr [edx] ; mov bh, 0xa ; push cs ; adc al, 0x43 ; ret
0x080e40bd : add al, byte ptr [edx] ; mov edx, 0x43140e0a ; ret
0x080db9dd : add al, byte ptr [edx] ; pop ecx ; ret
0x080eae12 : add al, byte ptr [esi + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080e2709 : add al, byte ptr [esi + 0xa] ; push cs ; adc al, 0x43 ; ret
0x080e3d3c : add al, byte ptr [esi + 0xa] ; ret
0x080dce7e : add al, byte ptr [esi + ecx + 4] ; ret
0x0808b18b : add al, ch ; call edi
0x080ded77 : add al, ch ; idiv eax ; jmp esi
0x080e4a4f : add al, ch ; ret 0
0x080e182f : add al, cl ; nop ; add byte ptr [eax], al ; or al, 0x98 ; stc ; jmp dword ptr [ebx]
0x080e952f : add al, cl ; or eax, 0x75ac0001 ; cld ; call dword ptr [esi]
0x080de02f : add al, cl ; pop eax ; add byte ptr [eax], al ; in al, dx ; cmpsd dword ptr [esi], dword ptr es:[edi] ; clc ; call dword ptr [ebx]
0x080db9b5 : add al, cl ; ret
0x080e2a53 : add al, cl ; xchg eax, ecx ; add byte ptr [eax], al ; cwde ; jl 0x80e2a5d ; call edi
0x080dc094 : add al, dh ; or cl, byte ptr [esi] ; adc al, 0x43 ; ret
0x080da081 : add al, dh ; push cs ; adc al, 0x41 ; ret
0x080e4b57 : add al, dh ; ret
0x080e7d37 : add al, dl ; cmc ; add byte ptr [eax], al ; je 0x80e7d30 ; sti ; call dword ptr [edi]
0x080e6580 : add al, dl ; or cl, byte ptr [esi] ; adc al, 0x43 ; ret
0x080e8537 : add al, dl ; std ; add byte ptr [eax], al ; movsb byte ptr es:[edi], byte ptr [esi] ; and al, 0xfc ; jmp dword ptr [edi]
0x080e376f : add al, dl ; xchg eax, ebx ; cli ; call eax
0x080d439e : add bh, 0x63 ; hlt ; das ; hlt ; stosb byte ptr es:[edi], al ; cli ; inc edx ; ret 0xac65
0x0805391b : add bh, al ; inc eax ; or byte ptr [eax], al ; add byte ptr [eax], al ; add bl, dh ; ret
0x08053a2b : add bh, al ; inc eax ; pop esp ; add byte ptr [eax], al ; add byte ptr [eax], al ; pop ebx ; ret
0x0807a7d5 : add bh, al ; ret 0xffd8
0x08051fef : add bh, al ; ret 0xffe8
0x08083696 : add bh, al ; ret 0xfff8
0x0807f315 : add bh, al ; test dword ptr [ebx + edi*8 - 1], esi ; call dword ptr [eax]
0x08086881 : add bh, al ; test dword ptr [edi + edi*8 - 1], esi ; call dword ptr [eax]
0x0808e9c9 : add bh, bh ; adc eax, 0x80eceb0 ; pop ebx ; ret
0x08091194 : add bh, bh ; adc eax, 0x80eceb0 ; ret
0x0805bbc2 : add bh, bh ; add byte ptr [ecx + eax + 0x40], dh ; pop edi ; pop esi ; ret
0x0805c31e : add bh, bh ; add byte ptr [ecx + eax + 0x40], dh ; pop edi ; ret
0x08072dbb : add bh, bh ; je 0x8072dec ; inc eax ; push dword ptr [esp + 0x40] ; call edi
0x08072ee9 : add bh, bh ; je 0x8072f1a ; inc esp ; push dword ptr [esp + 0x44] ; call edi
0x080734fb : add bh, bh ; je 0x807352c ; inc eax ; push dword ptr [esp + 0x40] ; call esi
0x08073b1b : add bh, bh ; je 0x8073b4c ; inc esp ; push dword ptr [esp + 0x44] ; call edi
0x08073e01 : add bh, bh ; je 0x8073e32 ; inc eax ; push dword ptr [esp + 0x40] ; call edi
0x0807452a : add bh, bh ; je 0x807455b ; push eax ; push dword ptr [esp + 0x50] ; call ebx
0x08074f79 : add bh, bh ; je 0x8074faa ; pop esp ; push dword ptr [esp + 0x5c] ; call edi
0x08075d09 : add bh, bh ; je 0x8075d3a ; push eax ; push dword ptr [esp + 0x50] ; call edi
0x08076261 : add bh, bh ; je 0x8076292 ; dec eax ; push dword ptr [esp + 0x48] ; call edi
0x08076a49 : add bh, bh ; je 0x8076a7a ; dec esp ; push dword ptr [esp + 0x4c] ; call edi
0x08076f81 : add bh, bh ; je 0x8076fb2 ; dec eax ; push dword ptr [esp + 0x48] ; call edi
0x0808bdbc : add bh, bh ; jne 0x808bddb ; push eax ; push esi ; push edi ; call ebx
0x080e371b : add bh, bh ; or cl, byte ptr [esi] ; adc al, 0x41 ; ret
0x080a5d29 : add bh, bh ; xor eax, 0x80ee1a8 ; call eax
0x0807ed8f : add bh, bl ; or al, 8 ; jmp eax
0x080e9484 : add bh, byte ptr [eax + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080dbfcd : add bh, byte ptr [eax + 0xa] ; ret
0x080dff2c : add bh, byte ptr [ebp + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080e1689 : add bh, byte ptr [ebp + 0xa] ; ret
0x080dcfc0 : add bh, byte ptr [ebx + 0x41140e0a] ; ret
0x080dffdb : add bh, byte ptr [ebx + 0xa] ; push cs ; adc al, 0x43 ; ret
0x080dc8b5 : add bh, byte ptr [ecx + 0x43080e0a] ; ret
0x080dfd54 : add bh, byte ptr [ecx + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080df944 : add bh, byte ptr [ecx + 0xa] ; ret
0x08081f47 : add bh, byte ptr [ecx] ; ret 0x8d0f
0x080da829 : add bh, byte ptr [edi + 0xa] ; ret
0x080e40be : add bh, byte ptr [edx + 0x43140e0a] ; ret
0x080e3d03 : add bh, byte ptr [edx + 0xa] ; ret
0x080e06d8 : add bh, byte ptr [edx + ecx + 0xe] ; adc al, 0x41 ; ret
0x080dcc0c : add bh, byte ptr [esi + 0x43140e0a] ; ret
0x080dcba8 : add bh, byte ptr [esi + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080e509c : add bh, byte ptr [esi + 0xa] ; ret
0x080dd9bf : add bh, byte ptr [esi + ecx + 4] ; ret
0x080daaf3 : add bh, ch ; or cl, byte ptr [esi] ; adc al, 0x41 ; ret
0x08048d5d : add bh, cl ; push cs ; or byte ptr [ecx], ah ; ret 0x5489
0x080dc7bc : add bh, dh ; or cl, byte ptr [esi] ; adc al, 0x41 ; ret
0x0807076f : add bh, dh ; ret 0
0x08068915 : add bh, dh ; ret 0x3f
0x0805c558 : add bh, dh ; ret 0xf
0x080e16c1 : add bl, ah ; or cl, byte ptr [esi] ; adc al, 0x41 ; ret
0x080d9726 : add bl, byte ptr [eax + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080e4cc4 : add bl, byte ptr [ebp + 0x43140e0a] ; ret
0x080e49c1 : add bl, byte ptr [ebp + 0xa] ; push cs ; adc al, 0x41 ; ret
0x080e4ec9 : add bl, byte ptr [ebp + 0xa] ; ret
0x080de6dd : add bl, byte ptr [ebx + 0xa] ; ret
0x080ea45d : add bl, byte ptr [ecx + 0x41140e0a] ; ret
0x080e20e9 : add bl, byte ptr [ecx + 0xa] ; push cs ; adc al, 0x43 ; ret
0x080e1328 : add bl, byte ptr [ecx + 0xa] ; ret
0x080dcb04 : add bl, byte ptr [edi + 0x46140e0a] ; ret
0x080e380e : add bl, byte ptr [edi + 0xa] ; push cs ; adc al, 0x43 ; ret
0x080de7a9 : add bl, byte ptr [edi + 0xa] ; ret
0x0808db87 : add bl, byte ptr [edi - 0x3d] ; add eax, 3 ; pop edi ; ret
0x080e4431 : add bl, byte ptr [edx + 0x41140e0a] ; ret
0x080d9b4b : add bl, byte ptr [edx + 0xa] ; push cs ; adc al, 0x47 ; ret
0x080da35a : add bl, byte ptr [edx + ecx + 0xe] ; adc al, 0x41 ; ret
0x080e4e8f : add bl, byte ptr [esi + 0x41100e0a] ; ret
0x080a6f94 : add bl, byte ptr [esi + 0x5f] ; ret
0x080e9564 : add bl, ch ; or cl, byte ptr [esi] ; adc al, 0x43 ; ret
0x0806da3d : add bl, ch ; ret 0x448b
0x0804d766 : add bl, ch ; ret 0x7c89
0x08052cc9 : add bl, dh ; ret
0x0809852c : add bl, dl ; loopne 0x809856d ; ret
0x080b7af5 : add bl, dl ; loopne 0x80b7af6 ; fmul dword ptr [ecx] ; ret
0x080b7b5d : add bl, dl ; loopne 0x80b7b5e ; fmul dword ptr [ecx] ; ret
0x080b7d4d : add bl, dl ; loopne 0x80b7d4e ; fmul dword ptr [ecx] ; ret
0x0809c4f5 : add byte ptr [0xfffffffc], al ; ret
0x080def55 : add byte ptr [bx + si], al ; js 0x80def5c ; clc ; call dword ptr [eax]
0x080ea1af : add byte ptr [eax + 0x1a], cl ; add dword ptr [eax], eax ; sbb al, 0xce ; cld ; call dword ptr [eax]
0x080da4b7 : add byte ptr [eax + 0x1d], dl ; add byte ptr [eax], al ; xchg eax, esp ; jo 0x80da4be ; call dword ptr [eax]
0x0806c097 : add byte ptr [eax + 0x450ff0e5], al ; ret
0x080daf0f : add byte ptr [eax + 0x4c000027], ch ; test dh, bh ; call edi
0x08087e37 : add byte ptr [eax + 0x50], dl ; push 0x2b ; jmp 0x8087e07