This file is indexed.

/usr/lib/radare/bin/adict is in radare-common 1:1.5.2-6.

This file is owned by root:root, with mode 0o755.

The actual contents of the file can be viewed below.

   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
1001
#!/usr/bin/env perl
# intel:  x86ref
# intel:  http://lorca.act.uji.es/e08/ayudas/intel/INST8088.HTM
# arm :   http://infopad.eecs.berkeley.edu/research/pico_radio/Test_Bed/Hardware/Documentation/ARM/ARM_Instruction_Set.pdf
# 

my %ops=(
#xml
	"add" => "add",
	"push" => "push word, doubleword or quadword onto the stack",
	"pop" => "pop a value from the stack",
	"or" => "logical inclusive or",
	"push" => "push word, doubleword or quadword onto the stack",
	"pop" => "pop a value from the stack",
	"adc" => "add with carry",
	"push" => "push word, doubleword or quadword onto the stack",
	"pop" => "pop a value from the stack",
	"sbb" => "integer subtraction with borrow",
	"push" => "push word, doubleword or quadword onto the stack",
	"pop" => "pop a value from the stack",
	"and" => "logical and",
	"es" => "es segment override prefix",
	"daa" => "decimal adjust al after addition",
	"sub" => "subtract",
	"cs" => "cs segment override prefix",
	"das" => "decimal adjust al after subtraction",
	"xor" => "logical exclusive or",
	"ss" => "ss segment override prefix",
	"aaa" => "ascii adjust after addition",
	"cmp" => "compare two operands",
	"ds" => "ds segment override prefix",
	"aas" => "ascii adjust al after subtraction",
	"inc" => "increment by 1",
	"rex" => "access to new 8-bit registers",
	"rex.b" => "extension of r/m field, base field, or opcode reg field",
	"rex.x" => "extension of sib index field",
	"rex.xb" => "rex.x and rex.b combination",
	"rex.r" => "extension of modr/m reg field",
	"rex.rb" => "rex.r and rex.b combination",
	"rex.rx" => "rex.r and rex.x combination",
	"rex.rxb" => "rex.r, rex.x and rex.b combination",
	"dec" => "decrement by 1",
	"rex.w" => "64 bit operand size",
	"rex.wb" => "rex.w and rex.b combination",
	"rex.wx" => "rex.w and rex.x combination",
	"rex.wxb" => "rex.w, rex.x and rex.b combination",
	"rex.wr" => "rex.w and rex.r combination",
	"rex.wrb" => "rex.w, rex.r and rex.b combination",
	"rex.wrx" => "rex.w, rex.r and rex.x combination",
	"rex.wrxb" => "rex.w, rex.r, rex.x and rex.b combination",
	"push" => "push word, doubleword or quadword onto the stack",
	"pop" => "pop a value from the stack",
	"pusha" => "push all general-purpose registers",
	"pushad" => "push all general-purpose registers",
	"popa" => "pop all general-purpose registers",
	"popad" => "pop all general-purpose registers",
	"bound" => "check array index against bounds",
	"arpl" => "adjust rpl field of segment selector",
	"movsxd" => "move with sign-extension",
	"fs" => "fs segment override prefix",
	"gs" => "gs segment override prefix",
	"push" => "push word, doubleword or quadword onto the stack",
	"imul" => "signed multiply",
	"push" => "push word, doubleword or quadword onto the stack",
	"imul" => "signed multiply",
	"ins" => "input from port to string",
	"ins" => "input from port to string",
	"ins" => "input from port to string",
	"outs" => "output string to port",
	"outs" => "output string to port",
	"outs" => "output string to port",
	"jo" => "jump short if overflow (of=1)",
	"jno" => "jump short if not overflow (of=0)",
	"jb" => "jump short if below/not above or equal/carry (cf=1)",
	"jnb" => "jump short if not below/above or equal/not carry (cf=0)",
	"jz" => "jump short if zero/equal (zf=0)",
	"jnz" => "jump short if not zero/not equal (zf=1)",
	"jbe" => "jump short if below or equal/not above (cf=1 and zf=1)",
	"jnbe" => "jump short if not below or equal/above (cf=0 and zf=0)",
	"js" => "jump short if sign (sf=1)",
	"jns" => "jump short if not sign (sf=0)",
	"jp" => "jump short if parity/parity even (pf=1)",
	"jnp" => "jump short if not parity/parity odd",
	"jl" => "jump short if less/not greater (sf!=of)",
	"jnl" => "jump short if not less/greater or equal (sf=of)",
	"jle" => "jump short if less or equal/not greater ((zf=1) or (sf!=of))",
	"jnle" => "jump short if not less nor equal/greater ((zf=0) and (sf=of))",
	"add" => "add",
	"or" => "logical inclusive or",
	"adc" => "add with carry",
	"sbb" => "integer subtraction with borrow",
	"and" => "logical and",
	"sub" => "subtract",
	"xor" => "logical exclusive or",
	"cmp" => "compare two operands",
	"add" => "add",
	"or" => "logical inclusive or",
	"adc" => "add with carry",
	"sbb" => "integer subtraction with borrow",
	"and" => "logical and",
	"sub" => "subtract",
	"xor" => "logical exclusive or",
	"cmp" => "compare two operands",
	"add" => "add",
	"or" => "logical inclusive or",
	"adc" => "add with carry",
	"sbb" => "integer subtraction with borrow",
	"and" => "logical and",
	"sub" => "subtract",
	"xor" => "logical exclusive or",
	"cmp" => "compare two operands",
	"add" => "add",
	"or" => "logical inclusive or",
	"adc" => "add with carry",
	"sbb" => "integer subtraction with borrow",
	"and" => "logical and",
	"sub" => "subtract",
	"xor" => "logical exclusive or",
	"cmp" => "compare two operands",
	"test" => "logical compare",
	"xchg" => "exchange register/memory with register",
	"mov" => "move",
	"lea" => "load effective address",
	"mov" => "move",
	"pop" => "pop a value from the stack",
	"xchg" => "exchange register/memory with register",
	"nop" => "no operation",
	"pause" => "spin loop hint",
	"cbw" => "convert byte to word",
	"cwde" => "convert word to doubleword",
	"cbw" => "convert",
	"cwd" => "convert word to doubleword",
	"cdq" => "convert doubleword to quadword",
	"cwd" => "convert",
	"callf" => "call procedure",
	"fwait" => "check pending unmasked floating-point exceptions",
	"pushf" => "push flags register onto the stack",
	"pushfd" => "push eflags register onto the stack",
	"pushf" => "push rflags register onto the stack",
	"popf" => "pop stack into flags register",
	"popfd" => "pop stack into eflags register",
	"popf" => "pop stack into rflags register",
	"sahf" => "store ah into flags",
	"lahf" => "load status flags into ah register",
	"mov" => "move",
	"movs" => "move data from string to string",
	"movs" => "move data from string to string",
	"movs" => "move data from string to string",
	"movs" => "move data from string to string",
	"cmps" => "compare string operands",
	"cmps" => "compare string operands",
	"cmps" => "compare string operands",
	"cmps" => "compare string operands",
	"test" => "logical compare",
	"stos" => "store string",
	"stos" => "store string",
	"stos" => "store string",
	"stos" => "store string",
	"lods" => "load string",
	"lods" => "load string",
	"lods" => "load string",
	"lods" => "load string",
	"scas" => "scan string",
	"scas" => "scan string",
	"scas" => "scan string",
	"scas" => "scan string",
	"mov" => "move",
	"rol" => "rotate",
	"ror" => "rotate",
	"rcl" => "rotate",
	"rcr" => "rotate",
	"shl" => "shift",
	"shr" => "shift",
	"sal" => "shift",
	"sar" => "shift",
	"rol" => "rotate",
	"ror" => "rotate",
	"rcl" => "rotate",
	"rcr" => "rotate",
	"shl" => "shift",
	"shr" => "shift",
	"sal" => "shift",
	"sar" => "shift",
	"retn" => "return from procedure",
	"les" => "load far pointer",
	"lds" => "load far pointer",
	"mov" => "move",
	"enter" => "make stack frame for procedure parameters",
	"leave" => "high level procedure exit",
	"retf" => "return from procedure",
	"int" => "call to interrupt procedure",
	"into" => "call to interrupt procedure",
	"iret" => "interrupt return",
	"iretd" => "interrupt return",
	"iret" => "interrupt return",
	"rol" => "rotate",
	"ror" => "rotate",
	"rcl" => "rotate",
	"rcr" => "rotate",
	"shl" => "shift",
	"shr" => "shift",
	"sal" => "shift",
	"sar" => "shift",
	"rol" => "rotate",
	"ror" => "rotate",
	"rcl" => "rotate",
	"rcr" => "rotate",
	"shl" => "shift",
	"shr" => "shift",
	"sal" => "shift",
	"sar" => "shift",
	"rol" => "rotate",
	"ror" => "rotate",
	"rcl" => "rotate",
	"rcr" => "rotate",
	"shl" => "shift",
	"shr" => "shift",
	"sal" => "shift",
	"sar" => "shift",
	"rol" => "rotate",
	"ror" => "rotate",
	"rcl" => "rotate",
	"rcr" => "rotate",
	"shl" => "shift",
	"shr" => "shift",
	"sal" => "shift",
	"sar" => "shift",
	"aam" => "ascii adjust ax after multiply",
	"aad" => "ascii adjust ax before division",
	"salc" => "set al if carry",
	"xlat" => "table look-up translation",
	"fadd" => 	"fmul" => 	"fcom" => "compare real",
	"fcomp" => "compare real and pop",
	"fsub" => 	"fsubr" => 	"fdiv" => 	"fdivr" => 	"fld" => "load floating point value",
	"fxch" => "exchange register contents",
	"fst" => "store floating point value",
	"fnop" => "no operation",
	"fstp" => "store floating point value and pop",
	"fldenv" => "load x87 fpu environment",
	"fchs" => "change sign",
	"fabs" => "absolute value",
	"ftst" => "test",
	"fxam" => "examine",
	"fldcw" => "load x87 fpu control word",
	"fld1" => "load constant +1.0",
	"fldl2t" => "load constant log<sub>2</sub>10",
	"fldl2e" => "load constant log<sub>2</sub>e",
	"fldpi" => "load constant &#960;",
	"fldlg2" => "load constant log<sub>10</sub>2",
	"fldln2" => "load constant log<sub>e</sub>2",
	"fldz" => "load constant +0.0",
	"fnstenv" => "store x87 fpu environment",
	"fstenv" => "store x87 fpu environment",
	"f2xm1" => "compute 2<sup>x</sup>-1",
	"fyl2x" => "compute y &#215; log<sub>2</sub>x and pop",
	"fptan" => "partial tangent",
	"fpatan" => "partial arctangent and pop",
	"fxtract" => "extract exponent and significand",
	"fprem1" => "ieee partial remainder",
	"fdecstp" => "decrement stack-top pointer",
	"fincstp" => "increment stack-top pointer",
	"fnstcw" => "store x87 fpu control word",
	"fstcw" => "store x87 fpu control word",
	"fprem" => "partial remainder (for compatibility with i8087 and i287)",
	"fyl2xp1" => "compute y &#215; log<sub>2</sub>(x+1) and pop",
	"fsqrt" => "square root",
	"fsincos" => "sine and cosine",
	"frndint" => "round to integer",
	"fscale" => "scale",
	"fsin" => "sine",
	"fcos" => "cosine",
	"fiadd" => "add",
	"fcmovb" => "fp conditional move - below (cf=1)",
	"fimul" => "multiply",
	"fcmove" => "fp conditional move - equal (zf=1)",
	"ficom" => "compare integer",
	"fcmovbe" => "fp conditional move - below or equal (cf=1 or zf=1)",
	"ficomp" => "compare integer and pop",
	"fcmovu" => "fp conditional move - unordered (pf=1)",
	"fisub" => "subtract",
	"fisubr" => "reverse subtract",
	"fucompp" => "unordered compare floating point values and pop twice",
	"fidiv" => "divide",
	"fidivr" => "reverse divide",
	"fild" => "load integer",
	"fcmovnb" => "fp conditional move - not below (cf=0)",
	"fisttp" => "store integer with truncation and pop",
	"fcmovne" => "fp conditional move - not equal (zf=0)",
	"fist" => "store integer",
	"fcmovnbe" => "fp conditional move - below or equal (cf=0 and zf=0)",
	"fistp" => "store integer and pop",
	"fcmovnu" => "fp conditional move - not unordered (pf=0)",
	"fneni" => "enable npx interrupt",
	"feni" => "enable npx interrupt",
	"fneni" => "treated as integer nop",
	"fndisi" => "disable npx interrupt",
	"fdisi" => "disable npx interrupt",
	"fndisi" => "treated as integer nop",
	"fnclex" => "clear exceptions",
	"fclex" => "clear exceptions",
	"fninit" => "initialize floating-point unit",
	"finit" => "initialize floating-point unit",
	"fnsetpm" => "set protected mode",
	"fsetpm" => "set protected mode",
	"fnsetpm" => "treated as integer nop",
	"fld" => "load floating point value",
	"fucomi" => "unordered compare floating point values and set eflags",
	"fcomi" => "compare floating point values and set eflags",
	"fstp" => "store floating point value and pop",
	"fadd" => "add",
	"fmul" => "multiply",
	"fcom" => "compare real",
	"fcomp" => "compare real and pop",
	"fsub" => "subtract",
	"fsubr" => "reverse subtract",
	"fsub" => "subtract",
	"fdiv" => "divide",
	"fdivr" => "reverse divide",
	"fdiv" => "divide and pop",
	"fld" => "load floating point value",
	"ffree" => "free floating-point register",
	"fisttp" => "store integer with truncation and pop",
	"fst" => "store floating point value",
	"fstp" => "store floating point value and pop",
	"frstor" => "restore x87 fpu state",
	"fucom" => "unordered compare floating point values",
	"fucomp" => "unordered compare floating point values and pop",
	"fnsave" => "store x87 fpu state",
	"fsave" => "store x87 fpu state",
	"fnstsw" => "store x87 fpu status word",
	"fstsw" => "store x87 fpu status word",
	"fiadd" => "add",
	"faddp" => "add and pop",
	"fimul" => "multiply",
	"fmulp" => "multiply and pop",
	"ficom" => "compare integer",
	"ficomp" => "compare integer and pop",
	"fcompp" => "compare real and pop twice",
	"fisub" => "subtract",
	"fsubrp" => "reverse subtract and pop",
	"fisubr" => "reverse subtract",
	"fsubp" => "subtract and pop",
	"fidiv" => "divide",
	"fdivrp" => "reverse divide and pop",
	"fidivr" => "reverse divide",
	"fdivp" => "divide and pop",
	"fild" => "load integer",
	"fisttp" => "store integer with truncation and pop",
	"fist" => "store integer",
	"fistp" => "store integer and pop",
	"fbld" => "load binary coded decimal",
	"fnstsw" => "store x87 fpu status word",
	"fstsw" => "store x87 fpu status word",
	"fild" => "load integer",
	"fucomip" => "unordered compare floating point values and set eflags and pop",
	"fbstp" => "store bcd integer and pop",
	"fcomip" => "compare floating point values and set eflags and pop",
	"fistp" => "store integer and pop",
	"loopnz" => "decrement count; jump short if count!=0 and zf=0",
	"loopnz" => "decrement count; jump short if count!=0 and zf=0",
	"loopz" => "decrement count; jump short if count!=0 and zf=1",
	"loopz" => "decrement count; jump short if count!=0 and zf=1",
	"loop" => "decrement count; jump short if count!=0",
	"jcxz" => "jump short if ecx register is 0",
	"jrcxz" => "jump short if rcx register is 0",
	"in" => "input from port",
	"out" => "output to port",
	"call" => "call procedure",
	"jmp" => "jump",
	"jmpf" => "jump",
	"jmp" => "jump",
	"in" => "input from port",
	"out" => "output to port",
	"lock" => "assert lock# signal prefix",
	"int1" => "call to interrupt procedure",
	"repnz" => "repeat string operation prefix",
	"rep" => "repeat string operation prefix",
	"repnz" => "repeat string operation prefix",
	"rep" => "repeat string operation prefix",
	"repz" => "repeat string operation prefix",
	"rep" => "repeat string operation prefix",
	"repz" => "repeat string operation prefix",
	"rep" => "repeat string operation prefix",
	"hlt" => "halt",
	"cmc" => "complement carry flag",
	"test" => "logical compare",
	"not" => "one's complement negation",
	"neg" => "two's complement negation",
	"mul" => "unsigned multiply",
	"imul" => "signed multiply",
	"div" => "unsigned divide",
	"idiv" => "signed divide",
	"test" => "logical compare",
	"not" => "one's complement negation",
	"neg" => "two's complement negation",
	"mul" => "unsigned multiply",
	"imul" => "signed multiply",
	"div" => "unsigned divide",
	"idiv" => "signed divide",
	"clc" => "clear carry flag",
	"stc" => "set carry flag",
	"cli" => "clear interrupt flag",
	"sti" => "set interrupt flag",
	"cld" => "clear direction flag",
	"std" => "set direction flag",
	"inc" => "increment by 1",
	"dec" => "decrement by 1",
	"inc" => "increment by 1",
	"dec" => "decrement by 1",
	"call" => "call procedure",
	"callf" => "call procedure",
	"jmp" => "jump",
	"jmpf" => "jump",
	"push" => "push word, doubleword or quadword onto the stack",
	"sldt" => 	"str" => 	"lldt" => "load local descriptor table register",
	"ltr" => "load task register",
	"verr" => "verify a segment for reading",
	"verw" => "verify a segment for writing",
	"jmpe" => "jump to ia-64 instruction set",
	"sgdt" => "store global descriptor table register",
	"vmcall" => "call to vm monitor",
	"vmlaunch" => "launch virtual machine",
	"vmresume" => "resume virtual machine",
	"vmxoff" => "leave vmx operation",
	"sidt" => "store interrupt descriptor table register",
	"monitor" => "set up monitor address",
	"mwait" => "monitor wait",
	"lgdt" => "load global descriptor table register",
	"xgetbv" => "get value of extended control register",
	"xsetbv" => "set extended control register",
	"lidt" => "load interrupt descriptor table register",
	"smsw" => 	"lmsw" => "load machine status word",
	"invlpg" => "invalidate tlb entry",
	"swapgs" => "swap gs base register",
	"rdtscp" => "read time-stamp counter and processor id",
	"lar" => 	"lsl" => 	"loadall" => "load all of the cpu registers",
	"syscall" => "fast system call",
	"clts" => "clear task-switched flag in cr0",
	"loadall" => "load all of the cpu registers",
	"sysret" => "return from fast system call",
	"invd" => "invalidate internal caches",
	"wbinvd" => "write back and invalidate cache",
	"ud2" => "undefined instruction",
	"nop" => "no operation",
	"movups" => "move unaligned packed single-fp values",
	"movss" => "move scalar single-fp values",
	"movupd" => "move unaligned packed double-fp value",
	"movsd" => "move scalar double-fp value",
	"movups" => "move unaligned packed single-fp values",
	"movss" => "move scalar single-fp values",
	"movupd" => "move unaligned packed double-fp values",
	"movsd" => "move scalar double-fp value",
	"movhlps" => "move packed single-fp values high to low",
	"movlps" => "move low packed single-fp values",
	"movlpd" => "move low packed double-fp value",
	"movddup" => "move one double-fp and duplicate",
	"movsldup" => "move packed single-fp low and duplicate",
	"movlps" => "move low packed single-fp values",
	"movlpd" => "move low packed double-fp value",
	"unpcklps" => "unpack and interleave low packed single-fp values",
	"unpcklpd" => "unpack and interleave low packed double-fp values",
	"unpckhps" => "unpack and interleave high packed single-fp values",
	"unpckhpd" => "unpack and interleave high packed double-fp values",
	"movlhps" => "move packed single-fp values low to high",
	"movhps" => "move high packed single-fp values",
	"movhpd" => "move high packed double-fp value",
	"movshdup" => "move packed single-fp high and duplicate",
	"movhps" => "move high packed single-fp values",
	"movhpd" => "move high packed double-fp value",
	"hint_nop" => "hintable nop",
	"prefetchnta" => "prefetch data into caches",
	"prefetcht0" => "prefetch data into caches",
	"prefetcht1" => "prefetch data into caches",
	"prefetcht2" => "prefetch data into caches",
	"hint_nop" => "hintable nop",
	"nop" => "no operation",
	"hint_nop" => "hintable nop",
	"mov" => "move to/from control registers",
	"movaps" => "move aligned packed single-fp values",
	"movapd" => "move aligned packed double-fp values",
	"movaps" => "move aligned packed single-fp values",
	"movapd" => "move aligned packed double-fp values",
	"cvtpi2ps" => "convert packed dw integers to <!--1.11 packed -->single-fp values",
	"cvtsi2ss" => "convert dw integer to scalar single-fp value",
	"cvtpi2pd" => "convert packed dw integers to <!--1.11 packed -->double-fp values",
	"cvtsi2sd" => "convert dw integer to scalar double-fp value",
	"movntps" => "store packed single-fp values using non-temporal hint",
	"movntpd" => "store packed double-fp values using non-temporal hint",
	"cvttps2pi" => "convert with trunc. packed single-fp values to <!--1.11 packed -->dw integers",
	"cvttss2si" => "convert with trunc. scalar single-fp value to dw integer",
	"cvttpd2pi" => "convert with trunc. packed double-fp values to <!--1.11 packed -->dw integers",
	"cvttsd2si" => "conv. with trunc. scalar double-fp value to signed dw int",
	"cvtps2pi" => "convert packed single-fp values to <!--1.11 packed -->dw integers",
	"cvtss2si" => "convert scalar single-fp value to dw integer",
	"cvtpd2pi" => "convert packed double-fp values to <!--1.11 packed -->dw integers",
	"cvtsd2si" => "convert scalar double-fp value to dw integer",
	"ucomiss" => "unordered compare scalar single-fp values and set eflags",
	"ucomisd" => "unordered compare scalar double-fp values and set eflags",
	"comiss" => "compare scalar ordered single-fp values and set eflags",
	"comisd" => "compare scalar ordered double-fp values and set eflags",
	"wrmsr" => "write to model specific register",
	"rdtsc" => "read time-stamp counter",
	"rdmsr" => "read from model specific register",
	"rdpmc" => "read performance-monitoring counters",
	"sysenter" => "fast system call",
	"sysexit" => "fast return from fast system call",
	"getsec" => "getsec leaf functions",
	"pshufb" => "packed shuffle bytes",
	"phaddw" => "packed horizontal add",
	"phaddd" => "packed horizontal add",
	"phaddsw" => "packed horizontal add and saturate",
	"pmaddubsw" => "multiply and add packed signed and unsigned bytes",
	"phsubw" => "packed horizontal subtract",
	"phsubd" => "packed horizontal subtract",
	"phsubsw" => "packed horizontal subtract and saturate",
	"psignb" => "packed sign",
	"psignw" => "packed sign",
	"psignd" => "packed sign",
	"pmulhrsw" => "packed multiply high with round and scale",
	"pblendvb" => "variable blend packed bytes",
	"blendvps" => "variable blend packed single-fp values",
	"blendvpd" => "variable blend packed double-fp values",
	"ptest" => "logical compare",
	"pabsb" => "packed absolute value",
	"pabsw" => "packed absolute value",
	"pabsd" => "packed absolute value",
	"pmovsxbw" => 	"pmovsxbd" => 	"pmovsxbq" => 	"pmovsxwd" => 	"pmovsxwq" => 	"pmovsxdq" => 	"pmuldq" => "multiply packed signed dword integers",
	"pcmpeqq" => "compare packed qword data for equal",
	"movntdqa" => "load double quadword non-temporal aligned hint",
	"packusdw" => "pack with unsigned saturation",
	"pmovzxbw" => 	"pmovzxbd" => 	"pmovzxbq" => 	"pmovzxwd" => 	"pmovzxwq" => 	"pmovzxdq" => 	"pcmpgtq" => "compare packed qword data for greater than",
	"pminsb" => "minimum of packed signed byte integers",
	"pminsd" => "minimum of packed signed dword integers",
	"pminuw" => "minimum of packed unsigned word integers",
	"pminud" => "minimum of packed unsigned dword integers",
	"pmaxsb" => "maximum of packed signed byte integers",
	"pmaxsd" => "maximum of packed signed dword integers",
	"pmaxuw" => "maximum of packed unsigned word integers",
	"pmaxud" => "maximum of packed unsigned dword integers",
	"pmulld" => "multiply packed signed dword integers and store low result",
	"phminposuw" => "packed horizontal word minimum",
	"invept" => "invalidate translations derived from ept",
	"invvpid" => "invalidate translations based on vpid",
	"movbe" => "move data after swapping bytes",
	"crc32" => "accumulate crc32 value",
	"movbe" => "move data after swapping bytes",
	"crc32" => "accumulate crc32 value",
	"roundps" => "round packed single-fp values",
	"roundpd" => "round packed double-fp values",
	"roundss" => "round scalar single-fp values",
	"roundsd" => "round scalar double-fp values",
	"blendps" => "blend packed single-fp values",
	"blendpd" => "blend packed double-fp values",
	"pblendw" => "blend packed words",
	"palignr" => "packed align right",
	"pextrb" => 	"pextrw" => 	"pextrd" => "extract dword/qword",
	"extractps" => "extract packed single-fp value",
	"pinsrb" => 	"insertps" => 	"pinsrd" => "insert dword/qword",
	"dpps" => "dot product of packed single-fp values",
	"dppd" => "dot product of packed double-fp values",
	"mpsadbw" => "compute multiple packed sums of absolute difference",
	"pcmpestrm" => "packed compare explicit length strings, return mask",
	"pcmpestri" => "packed compare explicit length strings, return index",
	"pcmpistrm" => "packed compare implicit length strings, return mask",
	"pcmpistri" => "packed compare implicit length strings, return index",
	"cmovo" => "conditional move - overflow (of=1)",
	"cmovno" => "conditional move - not overflow (of=0)",
	"cmovb" => "conditional move - below/not above or equal/carry (cf=1)",
	"cmovnb" => "conditional move - not below/above or equal/not carry (cf=0)",
	"cmovz" => "conditional move - zero/equal (zf=0)",
	"cmovnz" => "conditional move - not zero/not equal (zf=1)",
	"cmovbe" => "conditional move - below or equal/not above (cf=1 and zf=1)",
	"cmovnbe" => "conditional move - not below or equal/above (cf=0 and zf=0)",
	"cmovs" => "conditional move - sign (sf=1)",
	"cmovns" => "conditional move - not sign (sf=0)",
	"cmovp" => "conditional move - parity/parity even (pf=1)",
	"cmovnp" => "conditional move - not parity/parity odd",
	"cmovl" => "conditional move - less/not greater (sf!=of)",
	"cmovnl" => "conditional move - not less/greater or equal (sf=of)",
	"cmovle" => "conditional move - less or equal/not greater ((zf=1) or (sf!=of))",
	"cmovnle" => "conditional move - not less nor equal/greater ((zf=0) and (sf=of))",
	"movmskps" => "extract packed single-fp sign mask",
	"movmskpd" => "extract packed double-fp sign mask",
	"sqrtps" => "compute square roots of packed single-fp values",
	"sqrtss" => "compute square root of scalar single-fp value",
	"sqrtpd" => "compute square roots of packed double-fp values",
	"sqrtsd" => "compute square root of scalar double-fp value",
	"rsqrtps" => "compute recipr. of square roots of packed single-fp values",
	"rsqrtss" => "compute recipr. of square root of scalar single-fp value",
	"rcpps" => "compute reciprocals of packed single-fp values",
	"rcpss" => "compute reciprocal of scalar single-fp values",
	"andps" => "bitwise logical and of packed single-fp values",
	"andpd" => "bitwise logical and of packed double-fp values",
	"andnps" => "bitwise logical and not of packed single-fp values",
	"andnpd" => "bitwise logical and not of packed double-fp values",
	"orps" => "bitwise logical or of single-fp values",
	"orpd" => "bitwise logical or of double-fp values",
	"xorps" => "bitwise logical xor for single-fp values",
	"xorpd" => "bitwise logical xor for double-fp values",
	"addps" => "add packed single-fp values",
	"addss" => "add scalar single-fp values",
	"addpd" => "add packed double-fp values",
	"addsd" => "add scalar double-fp values",
	"mulps" => "multiply packed single-fp values",
	"mulss" => "multiply scalar single-fp value",
	"mulpd" => "multiply packed double-fp values",
	"mulsd" => "multiply scalar double-fp values",
	"cvtps2pd" => "convert packed single-fp values to <!--1.11 packed -->double-fp values",
	"cvtpd2ps" => "convert packed double-fp values to <!--1.11 packed -->single-fp values",
	"cvtss2sd" => "convert scalar single-fp value to scalar double-fp value ",
	"cvtsd2ss" => "convert scalar double-fp value to scalar single-fp value",
	"cvtdq2ps" => "convert packed dw integers to <!--1.11 packed -->single-fp values",
	"cvtps2dq" => "convert packed single-fp values to <!--1.11 packed -->dw integers",
	"cvttps2dq" => "convert with trunc. packed single-fp values to <!--1.11 packed -->dw integers",
	"subps" => "subtract packed single-fp values",
	"subss" => "subtract scalar single-fp values",
	"subpd" => "subtract packed double-fp values",
	"subsd" => "subtract scalar double-fp values",
	"minps" => "return minimum packed single-fp values",
	"minss" => "return minimum scalar single-fp value",
	"minpd" => "return minimum packed double-fp values",
	"minsd" => "return minimum scalar double-fp value",
	"divps" => "divide packed single-fp values",
	"divss" => "divide scalar single-fp values",
	"divpd" => "divide packed double-fp values",
	"divsd" => "divide scalar double-fp values",
	"maxps" => "return maximum packed single-fp values",
	"maxss" => "return maximum scalar single-fp value",
	"maxpd" => "return maximum packed double-fp values",
	"maxsd" => "return maximum scalar double-fp value",
	"punpcklbw" => "unpack low data",
	"punpcklwd" => "unpack low data",
	"punpckldq" => "unpack low data",
	"packsswb" => "pack with signed saturation",
	"pcmpgtb" => "compare packed signed integers for greater than",
	"pcmpgtw" => "compare packed signed integers for greater than",
	"pcmpgtd" => "compare packed signed integers for greater than",
	"packuswb" => "pack with unsigned saturation",
	"punpckhbw" => "unpack high data",
	"punpckhwd" => "unpack high data",
	"punpckhdq" => "unpack high data",
	"packssdw" => "pack with signed saturation",
	"punpcklqdq" => "unpack low data",
	"punpckhqdq" => "unpack high data",
	"movd" => "move doubleword",
	"movq" => "move doubleword/quadword",
	"movd" => "move doubleword",
	"movq" => "move doubleword/quadword",
	"movdqa" => "move aligned double quadword",
	"movdqu" => "move unaligned double quadword",
	"pshufw" => "shuffle packed words",
	"pshuflw" => "shuffle packed low words",
	"pshufhw" => "shuffle packed high words",
	"pshufd" => "shuffle packed doublewords",
	"psrlw" => "shift packed data right logical",
	"psraw" => "shift packed data right arithmetic",
	"psllw" => "shift packed data left logical",
	"psrld" => "shift double quadword right logical",
	"psrad" => "shift packed data right arithmetic",
	"pslld" => "shift packed data left logical",
	"psrlq" => "shift packed data right logical",
	"psrldq" => "shift double quadword right logical",
	"psllq" => "shift packed data left logical",
	"pslldq" => "shift double quadword left logical",
	"pcmpeqb" => "compare packed data for equal",
	"pcmpeqw" => "compare packed data for equal",
	"pcmpeqd" => "compare packed data for equal",
	"emms" => "empty mmx technology state",
	"vmread" => "read field from virtual-machine control structure",
	"vmwrite" => "write field to virtual-machine control structure",
	"haddpd" => "packed double-fp horizontal add",
	"haddps" => "packed single-fp horizontal add",
	"hsubpd" => "packed double-fp horizontal subtract",
	"hsubps" => "packed single-fp horizontal subtract",
	"movd" => "move doubleword",
	"movq" => "move doubleword/quadword",
	"movd" => "move doubleword",
	"movq" => "move doubleword/quadword",
	"movdqa" => "move aligned double quadword",
	"movdqu" => "move unaligned double quadword",
	"jo" => "jump short if overflow (of=1)",
	"jno" => "jump short if not overflow (of=0)",
	"jb" => "jump short if below/not above or equal/carry (cf=1)",
	"jnb" => "jump short if not below/above or equal/not carry (cf=0)",
	"jz" => "jump short if zero/equal (zf=0)",
	"jnz" => "jump short if not zero/not equal (zf=1)",
	"jbe" => "jump short if below or equal/not above (cf=1 and zf=1)",
	"jnbe" => "jump short if not below or equal/above (cf=0 and zf=0)",
	"js" => "jump short if sign (sf=1)",
	"jns" => "jump short if not sign (sf=0)",
	"jp" => "jump short if parity/parity even (pf=1)",
	"jnp" => "jump short if not parity/parity odd",
	"jl" => "jump short if less/not greater (sf!=of)",
	"jnl" => "jump short if not less/greater or equal (sf=of)",
	"jle" => "jump short if less or equal/not greater ((zf=1) or (sf!=of))",
	"jnle" => "jump short if not less nor equal/greater ((zf=0) and (sf=of))",
	"seto" => "set byte on condition - overflow (of=1)",
	"setno" => "set byte on condition - not overflow (of=0)",
	"setb" => "set byte on condition - below/not above or equal/carry (cf=1)",
	"setnb" => "set byte on condition - not below/above or equal/not carry (cf=0)",
	"setz" => "set byte on condition - zero/equal (zf=0)",
	"setnz" => "set byte on condition - not zero/not equal (zf=1)",
	"setbe" => "set byte on condition - below or equal/not above (cf=1 and zf=1)",
	"setnbe" => "set byte on condition - not below or equal/above (cf=0 and zf=0)",
	"sets" => "set byte on condition - sign (sf=1)",
	"setns" => "set byte on condition - not sign (sf=0)",
	"setp" => "set byte on condition - parity/parity even (pf=1)",
	"setnp" => "set byte on condition - not parity/parity odd",
	"setl" => "set byte on condition - less/not greater (sf!=of)",
	"setnl" => "set byte on condition - not less/greater or equal (sf=of)",
	"setle" => "set byte on condition - less or equal/not greater ((zf=1) or (sf!=of))",
	"setnle" => "set byte on condition - not less nor equal/greater ((zf=0) and (sf=of))",
	"push" => "push word, doubleword or quadword onto the stack",
	"pop" => "pop a value from the stack",
	"cpuid" => "cpu identification",
	"bt" => "bit test",
	"shld" => "double precision shift left",
	"push" => "push word, doubleword or quadword onto the stack",
	"pop" => "pop a value from the stack",
	"rsm" => "resume from system management mode",
	"bts" => "bit test and set",
	"shrd" => "double precision shift right",
	"fxsave" => "save x87 fpu, mmx, xmm, and mxcsr state",
	"fxrstor" => "restore x87 fpu, mmx, xmm, and mxcsr state",
	"ldmxcsr" => "load mxcsr register",
	"stmxcsr" => "store mxcsr register state",
	"xsave" => "save processor extended states",
	"lfence" => "load fence",
	"xrstor" => "restore processor extended states",
	"mfence" => "memory fence",
	"sfence" => "store fence",
	"clflush" => "flush cache line",
	"imul" => "signed multiply",
	"cmpxchg" => "compare and exchange",
	"lss" => "load far pointer",
	"btr" => "bit test and reset",
	"lfs" => "load far pointer",
	"lgs" => "load far pointer",
	"movzx" => "move with zero-extend",
	"jmpe" => "jump to ia-64 instruction set",
	"popcnt" => "bit population count",
	"bt" => "bit test",
	"bts" => "bit test and set",
	"btr" => "bit test and reset",
	"btc" => "bit test and complement",
	"bsf" => "bit scan forward",
	"bsr" => "bit scan reverse",
	"movsx" => "move with sign-extension",
	"xadd" => "exchange and add",
	"cmpps" => "compare packed single-fp values",
	"cmpss" => "compare scalar single-fp values",
	"cmppd" => "compare packed double-fp values",
	"cmpsd" => "compare scalar double-fp values",
	"movnti" => "store doubleword using non-temporal hint",
	"pinsrw" => 	"pextrw" => "extract word",
	"shufps" => "shuffle packed single-fp values",
	"shufpd" => "shuffle packed double-fp values",
	"cmpxchg8b" => "compare and exchange bytes",
	"cmpxchg16b" => "compare and exchange bytes",
	"vmptrld" => "load pointer to virtual-machine control structure",
	"vmclear" => "clear virtual-machine control structure",
	"vmxon" => "enter vmx operation",
	"vmptrst" => "store pointer to virtual-machine control structure",
	"bswap" => "byte swap",
	"addsubpd" => "packed double-fp add/subtract",
	"addsubps" => "packed single-fp add/subtract",
	"psrlw" => "shift packed data right logical",
	"psrld" => "shift packed data right logical",
	"psrlq" => "shift packed data right logical",
	"paddq" => "add packed quadword integers",
	"pmullw" => "multiply packed signed integers and store low result",
	"movq" => "move quadword",
	"movq2dq" => "move quadword from mmx technology to xmm register",
	"movdq2q" => "move quadword from xmm to mmx technology register",
	"pmovmskb" => "move byte mask",
	"psubusb" => "subtract packed unsigned integers with unsigned saturation",
	"psubusw" => "subtract packed unsigned integers with unsigned saturation",
	"pminub" => "minimum of packed unsigned byte integers",
	"pand" => "logical and",
	"paddusb" => "add packed unsigned integers with unsigned saturation",
	"paddusw" => "add packed unsigned integers with unsigned saturation",
	"pmaxub" => "maximum of packed unsigned byte integers",
	"pandn" => "logical and not",
	"pavgb" => "average packed integers",
	"psraw" => "shift packed data right arithmetic",
	"psrad" => "shift packed data right arithmetic",
	"pavgw" => "average packed integers",
	"pmulhuw" => "multiply packed unsigned integers and store high result",
	"pmulhw" => "multiply packed signed integers and store high result",
	"cvtpd2dq" => "convert packed double-fp values to <!--1.11 packed -->dw integers",
	"cvttpd2dq" => "convert with trunc. packed double-fp values to <!--1.11 packed -->dw integers",
	"cvtdq2pd" => "convert packed dw integers to <!--1.11 packed -->double-fp values",
	"movntq" => "store of quadword using non-temporal hint",
	"movntdq" => "store double quadword using non-temporal hint",
	"psubsb" => "subtract packed signed integers with signed saturation",
	"psubsw" => "subtract packed signed integers with signed saturation",
	"pminsw" => "minimum of packed signed word integers",
	"por" => "bitwise logical or",
	"paddsb" => "add packed signed integers with signed saturation",
	"paddsw" => "add packed signed integers with signed saturation",
	"pmaxsw" => "maximum of packed signed word integers",
	"pxor" => "logical exclusive or",
	"lddqu" => "load unaligned integer 128 bits",
	"psllw" => "shift packed data left logical",
	"pslld" => "shift packed data left logical",
	"psllq" => "shift packed data left logical",
	"pmuludq" => "multiply packed unsigned dw integers",
	"pmaddwd" => "multiply and add packed integers",
	"psadbw" => "compute sum of absolute differences",
	"maskmovq" => "store selected bytes of quadword",
	"maskmovdqu" => "store selected bytes of double quadword",
	"psubb" => "subtract packed integers",
	"psubw" => "subtract packed integers",
	"psubd" => "subtract packed integers",
	"psubq" => "subtract packed quadword integers",
	"paddb" => "add packed integers",
	"paddw" => "add packed integers",
	"paddd" => "add packed integers",
# intel
	"movzx" => "move dst register size padding with zeroes",
	"sar" => "arithmetic right shift",
	"sal" => "arithmetic left shift",
	"shl" => "logic left shift (0 padding)",
	"shr" => "logic right shift (0 padding)",
	"inc" => "register++",
	"dec" => "register--",
	"xlat"=> "al = [ebx+al]",
	"lahf"=> "AH = SF:ZF:X:AF:X:PF:X:CF",
	"sahf"=> "eflags(SF:ZF:X:AF:X:PF:X:CF) = AX",
	"lea" => "load efective address",
	"rol" => "rotate bits left",
	"ror" => "rotate bits right",
	"rcl" => "rotate bits left (with CF)",
	"rcr" => "rotate bits right (with CF)",
	"add" => "adds src and dst, stores result on dst",
	"and" => "binary and operation between src and dst, stores result on dst",
	"xor" => "exclusive or x^=y (x86) or x = y ^ z (arm)",
	"sub" => "substract src and dst, stores result on dst",
	"jmp" => "changes eip to another position",
	"call"=> "calls a subroutine, pushes eip into stack (esp)",
	"push"=> "pushes the argument to stack (esp)",
	"pop" => "pops last element of stack and stores the result in argument",
	"mov" => "moves data from src to dst",
	"nop" => "does nothing (nop [eax] (0F 1X XX) performs a memory read and nops)",
	"movsb"=>"ES:[edi] = (byte)DS:[esi] (esi++, edi++)",
	"movsw"=>"ES:[edi] = (word)DS:[esi] (esi+=2, edi+=2)",
	"movsd"=>"ES:[edi] = (dword)DS:[esi] (esi+=4, edi+=4)",
	"lodsb"=>"al = (byte)DS:[esi] (esi++)",
	"lodsw"=>"ax = (word)DS:[esi] (esi+=2)",
	"stosb"=>"ES:[edi] = al (edi++)",
	"cmpsb"=>"cmp DS:[SI], ES:[edi] (esi++, edi++)",
	"scasb"=>"cmp al, ES:[edi++]",
	"scasw"=>"cmp ax, ES:[edi+=2]",
	"rep" => "repeats next instruction ECX times",
	"ret" => "return from subroutine. pop 4 bytes from esp and jump there.",
	"enter" => "alias for push ebp mov ebp, esp",
	"leave" => "one byte alias for mov esp, ebp ; pop ebp",
	"clc" => "eflags[CF] = 0",
	"stc" => "eflags[CF] = 1",
	"cld" => "elfags[DF] = 0",
	"std" => "elfags[DF] = 1",
	"cli" => "elfags[IF] = 0",
	"sti" => "elfags[IF] = 1",
	"hlt" => "stop process until external interrupt received",
	"wait"=> "stop process execution until TEST pin activated",
	"lock" => "instruction prefix to setup the LOCK pin",
	"retn" =>"ret* to the same code segment",
	"retf" =>"ret* to other code segment",
	"test" =>"set eflags after comparing two registers (AF, CF, OF, PF, SF, ZF)",
	"jcxz" =>"Jump if ecx = 0",
	"loop" =>"if (ecx-- == 0) jmp ..",
	"loopz"=>"if (ecx-- == 0 && eflags[ZF] == 1) jmp ..",
	"into" =>"interrupt if eflags[OF]=1",
	"iret" => "return from interrupt",
# i387
	"fdiv" => "floating divide",
	"fdivp" => "floating divide and pop",
	"fdivr" => "floating divide reversed",
	"fdivrp" => "floating divide reversed and pop",
	"fidiv" => "integer divide",
	"fidivr" => "integer divide reserved",
	"feni" => "enable interrupts",
	"fneni" => "enable interrupts, no wait",
	"ffree" => "free register",
	"fiadd" => "integer add",
	"ficom" => "integer compare",
	"ficomp" => "integer compare and pop",
	"fild" => "load integer",
	"fimul" => "integer multiply",
	"fabs" => "absolute value",
	"fadd" => "floating point add",
	"faddp" => "floating point add and pop",
	"fbld" => "load bcd",
	"fbstp" => "store bcd and pop",
	"fchs" => "change sign",
	"fclex" => "clear exceptions",
	"fnclex" => "clear exceptions, no wait",
	"fcom" => "floating point compare",
	"fcomp" => "floating point compare and pop",
	"fcompp" => "floating point compare and pop twice",
	"fcos" => "floating point cosine",
	"finit" => "initialize fpu",
	"fninit" => "initialize fpu, no wait",
	"fist" => "store integer",
	"fistp" => "store integer and pop",
	"fisub" => "integer substract",
	"fisubr" => "integer susbtract reversed",
	"fld" => "floatint point load",
	"fldz" => "load constant onto stack 0.0f",
	"fld1" => "load constant onto stack 1.0f",
	"fldl2e" => "load constant onto stack, logarithm base 2 (e)",
	"fldl2t" => "load constant onto stack, logarithm base 2 (10)",
	"fldlg2" => "load constant onto stack, logarithm base 10 (2)",
	"fldln2" => "load constant onto stack, natural logarithm (2)",
	"fldpi" => "load constant onto stack, 3.14159..",
	"fldcw" => "load control word",
	"fldenv" => "load environment state",
	"fmul" => "floating point multiply",
	"fmulp" => "floating point multiply and pop",
	"fnop" => "no operation",
	"fincstp" => "increment floating point stack pointer (%foo)",
	"fdecstp" => "decrement floating point stack pointer (%foo)",
	"fdisi" => "disable interrupts",
	"fndisi" => "disable interrupts, no wait",
# ARM
	"b"   => "branches the program counter to dst (pc aka r15)",
	"bl"  => "branches and link, similar to call in i386, set lr(r14) = pc, changes pc (r15) )",
	"bx"  => "branches and exchanges cpu mode to 16 bits (thumb mode)",
	"bxj" => "branches and exchanges cpu mode to Jazzele (jumps to a bytecode vector)",
	"beq" => "branches if equal (see 'b')",
	"bne" => "branches if not equal (see 'b')",
	"cmp" => "compares two registers",
	"str" => "stores (TODO)",
	"ldr" => "load to register(TODO)",
	"ldf" => "armfpu: load float value pointed by reg+(offset): ldf f0, [r0,#off]",
	"stf" => "armfpu: store float value pointed by reg+(offset): ldf [r0,#off]",
	"flt" => "armfpu: convert int to float: flt ",
	"wfs" => "armfpu: write fp status register. wfs r0",
# PPC
# r0 = call arg, return value
# r1 = stack pointer
# r2 = rtoc (register table of contents) (like a5 68k reg, not used, global to func (if i dont call a func))
# r3-r10 - general purpose registers
	"bgt" => "Branch if greater or equal (PPC: bgt CRn, addr, ARM: bgt addr)",
	"sc" => "Syscall - see svc for supervisor call on powerpc",
	"dbnz" => "Decrement counter and branch if not zero",
	"dbz" => "Decrement counter and branch if zero",
	"li"  => "powerpc: load integer into register; li r3, 1",
	"mtctr" => "powerpc: preload count register (???)",
	"addic" => "powerpc: add integer to register with carry: addic r3, r3, 1",
	"lwz" => "load word and zero (32b); lwzu   r3,4(r4)      ; r4 = r4 + 4 ; r3 = *(r4)",
	"lhz" => "load half word and zero (16b)",
	"lbz" => "load byte and zero (8b)",
	"lbzu" => "powerpc: lbzu     r8,1(r4)     ;  r8 = *(++p2)",
	"cmpw" => "compare word; cmpw CR0, r0, r1 (signed)",
	"cmplw" => "compare logical word; cmplwi CR0, r0, 33(unsigned)",
	"cmplwi" => "compare logical word against int; cmplwi CR0, r0, 33(unsigned)",
	"bctr" => "Branch to counter register",
	"bcctr" => "Conditional branch to counter register",
	"svc" => "The svc instruction generates a supervisor call interrupt and places
bits 16-31 of the svc instruction into bits 0-15 of the
Count Register (CR) and bits 16-31 of the Machine State
Register (MSR) into bits 16-31 of the CR.

Consider the following when using the svc instruction:

    * If the SVC Absolute bit (SA) is set to 0, the instruction fetch
      and execution continues at one of the 128 offsets, b'1'|| LEV ||b'00000',
      to the base effective address (EA) indicated by the setting of the IP bit
      of the MSR. FL1 and FL2 fields could be used for passing data to the SVC
      routine but are ignored by hardware.

    * If the SVC Absolute bit (SA) is set to 1, then instruction fetch and
      execution continues at the offset, x'1FE0', to the base EA indicated by
      the setting of the IP bit of the MSR.

    * If the Link bit (LK) is set to 1, the EA of the instruction following the
      svc instruction is placed in the Link Register.

    Notes:
      1. To ensure correct operation, an svc instruction must be preceded by an
         unconditional branch or a CR instruction. If a useful instruction cannot
         be scheduled as specified, use a no-op version of the cror instruction
         with the following syntax:

       cror BT,BA,BB      No-op when BT = BA = BB

      2. The svc instruction has the same op code as the sc (System Call) instruction."
);

if ( $ARGV[0] eq "" ) {
	print "Usage: rsc adict [-l] [opcode] ; support java, intel, arm and powerpc opcodes\n";
	print "  example: $ rsc adict 'nop'\n";
	exit 0;
}

if ($ops{$ARGV[0]}) {
	print $ARGV[0]."   ".$ops{$ARGV[0]}."\n";
} else {
	print "unknown opcode\n";
}