- enhancement: Show descriptions mouse tip for assebmly instructions. (editor / cpu info dialog)

- fix: When completing resigter names, an extra '%' is wrongly added.

NEWS.md

@@ -2,7 +2,7 @@ Red Panda C++ Version 2.15
 
   - fix: Static class members is not correctly recognized as static.
   - fix: Function with reference type return value is not correctly parsed.
-  - enhancement: Add descriptions for x86 registers in the cpu info dialog.
+  - enhancement: Add description tooltips for x86 registers in the cpu info dialog.
   - fix: Search dialog shouldn't have "prompt when replace".
   - change: Default value for the debugger debugger panel "memory view's columns" is changed from 8 to 16.
   - change: Default value for the debugger debugger panel "memory view's rows" is changed from 8 to 16.
@@ -11,6 +11,8 @@ Red Panda C++ Version 2.15
   - enhancement: Auto close other search/replace dialogs when start to search/replace.
   - change: Remove "prompt when replace" in the replace.
   - fix: Search/replace with regex is not correctly handled.
+  - enhancement: Show descriptions mouse tip for assebmly instructions. (editor / cpu info dialog)
+  - fix: When completing resigter names, an extra '%' is wrongly added.  
 
 Red Panda C++ Version 2.14
 

RedPandaIDE/RedPandaIDE.pro

@@ -450,7 +450,9 @@ TRANSLATIONS += \
     translations/RedPandaIDE_pt_BR.ts
 
 EXTRA_TRANSLATIONS += \
-    ../libs/redpanda_qt_utils/qt_utils_zh_CN.ts
+    ../libs/redpanda_qt_utils/qt_utils_zh_CN.ts \
+    ../libs/qsynedit/qsynedit_zh_CN.ts
+
 
 #CONFIG += lrelease embed_translations
 

RedPandaIDE/editor.cpp

@@ -206,9 +206,10 @@ Editor::Editor(QWidget *parent, const QString& filename,
         mAutoBackupTimer.setInterval(1);
         connect(&mAutoBackupTimer, &QTimer::timeout,
             this, &Editor::onAutoBackupTimer);
+    }
+
     connect(&mTooltipTimer, &QTimer::timeout,
             this, &Editor::onTooltipTimer);
-    }
 
     connect(horizontalScrollBar(), &QScrollBar::valueChanged,
             this, &Editor::onScrollBarValueChanged);
@@ -1909,6 +1910,17 @@ void Editor::onTooltipTimer()
             s = expression.join(""); // information during coding
         }
         break;
+    case TipType::Keyword:
+        if (syntaxer() &&
+                (syntaxer()->language() == QSynedit::ProgrammingLanguage::Assembly
+                 || syntaxer()->language() == QSynedit::ProgrammingLanguage::ATTAssembly)
+                ) {
+            if (!mCompletionPopup->isVisible()
+                 && !mHeaderCompletionPopup->isVisible()) {
+                s = wordAtRowCol(p);
+            }
+        }
+        break;
     case TipType::Selection:
         s = selText(); // when a selection is available, always only use that
         break;
@@ -1938,7 +1950,6 @@ void Editor::onTooltipTimer()
             mHoverModifiedLine=line;
         }
     }
-
     // Remove hint
     cancelHint();
     mCurrentWord = s;
@@ -1966,11 +1977,21 @@ void Editor::onTooltipTimer()
             if (pMainWindow->debugger()->executing()
                     && (pSettings->editor().enableDebugTooltips())) {
                 showDebugHint(s,p.line);
-            } else if (pSettings->editor().enableIdentifierToolTips()) { //if devEditor.ParserHints {
+            } else if (pSettings->editor().enableIdentifierToolTips()) {
                 hint = getParserHint(expression, s, p.line);
             }
         }
         break;
+    case TipType::Keyword:
+        if (pSettings->editor().enableIdentifierToolTips()) {
+            if (syntaxer() &&
+                    (syntaxer()->language() == QSynedit::ProgrammingLanguage::Assembly
+                     || syntaxer()->language() == QSynedit::ProgrammingLanguage::ATTAssembly)
+                    ) {
+                hint = QSynedit::ASMSyntaxer::Instructions.value(s.toLower(),"");
+            }
+        }
+        break;
     case TipType::Error:
         if (pSettings->editor().enableIssueToolTips())
             hint = getErrorHint(pError);
@@ -3324,7 +3345,7 @@ void Editor::showCompletion(const QString& preWord,bool autoComplete, CodeComple
                 else if (word.startsWith("%"))
                     keywords = QSynedit::ASMSyntaxer::ATTRegisters;
                 else
-                    keywords = QSynedit::ASMSyntaxer::Instructions;
+                    keywords = QSynedit::ASMSyntaxer::InstructionNames;
             } else {
                 int pos = word.lastIndexOf(".");
                 if (pos>=0) {
@@ -3557,7 +3578,7 @@ void Editor::completionInsert(bool appendFunc)
     QSynedit::BufferCoord pStart = wordStart();
     if (syntaxer() && syntaxer()->language()==QSynedit::ProgrammingLanguage::ATTAssembly) {
         if (statement->command.startsWith(".")
-                || statement->command.startsWith("#"))
+                || statement->command.startsWith("%"))
             pStart.ch--;
     }
     setCaretAndSelection(pStart,pStart,p);
@@ -3828,8 +3849,11 @@ Editor::TipType Editor::getTipType(QPoint point, QSynedit::BufferCoord& pos)
                         return TipType::Selection;
                 } else if (mParser && mParser->isIncludeLine(document()->getLine(pos.line-1))) {
                     return TipType::Preprocessor;
-                }else if (attr == syntaxer()->identifierAttribute())
+                }else if (attr->tokenType() == QSynedit::TokenType::Identifier) {
                     return TipType::Identifier;
+                } else if (attr->tokenType() == QSynedit::TokenType::Keyword) {
+                    return TipType::Keyword;
+                }
             }
         }
     }
@@ -3843,7 +3867,6 @@ void Editor::cancelHint()
         mHoverModifiedLine=-1;
     }
 
-    //MainForm.Debugger.OnEvalReady := nil;
 
     // disable editor hint
     QToolTip::hideText();

RedPandaIDE/editor.h

@@ -104,6 +104,7 @@ public:
       Preprocessor, // cursor hovers above preprocessor line
       Identifier, // cursor hovers above identifier
       Selection, // cursor hovers above selection
+      Keyword,
       None, // mouseover not allowed
       Error //Cursor hovers above error line/item;
     };

RedPandaIDE/mainwindow.cpp

@@ -415,6 +415,17 @@ MainWindow::MainWindow(QWidget *parent)
     connect(ui->menuProject, &QMenu::aboutToShow,
             this, &MainWindow::updateProjectActions);
 
+    QString cpuArch = QSysInfo::currentCpuArchitecture();
+    if (cpuArch == "i386") {
+        ui->actionIA_32_Assembly_Language_Reference_Manual->setVisible(true);
+        ui->actionx86_Assembly_Language_Reference_Manual->setVisible(false);
+    } else if (cpuArch=="x86_64") {
+        ui->actionIA_32_Assembly_Language_Reference_Manual->setVisible(true);
+        ui->actionx86_Assembly_Language_Reference_Manual->setVisible(true);
+    } else {
+        ui->actionIA_32_Assembly_Language_Reference_Manual->setVisible(false);
+        ui->actionx86_Assembly_Language_Reference_Manual->setVisible(false);
+    }
     ui->actionEGE_Manual->setVisible(pSettings->environment().language()=="zh_CN");
     ui->actionDocument->setVisible(pSettings->environment().language()=="zh_CN");
 
@@ -9553,3 +9564,15 @@ void MainWindow::on_actionGNU_Assembler_Manual_triggered()
 {
     QDesktopServices::openUrl(QUrl("https://sourceware.org/binutils/docs/as/index.html"));
 }
+
+void MainWindow::on_actionx86_Assembly_Language_Reference_Manual_triggered()
+{
+    QDesktopServices::openUrl(QUrl("https://docs.oracle.com/cd/E19120-01/open.solaris/817-5477/index.html"));
+}
+
+
+void MainWindow::on_actionIA_32_Assembly_Language_Reference_Manual_triggered()
+{
+    QDesktopServices::openUrl(QUrl("https://docs.oracle.com/cd/E19455-01/806-3773/index.html"));
+}
+

RedPandaIDE/mainwindow.h

@@ -793,6 +793,10 @@ private slots:
 
     void on_actionGNU_Assembler_Manual_triggered();
 
+    void on_actionx86_Assembly_Language_Reference_Manual_triggered();
+
+    void on_actionIA_32_Assembly_Language_Reference_Manual_triggered();
+
 private:
     Ui::MainWindow *ui;
     bool mFullInitialized;

RedPandaIDE/mainwindow.ui

@@ -270,6 +270,8 @@
     <addaction name="actionC_Reference"/>
     <addaction name="actionC_C_Reference"/>
     <addaction name="actionGNU_Assembler_Manual"/>
+    <addaction name="actionx86_Assembly_Language_Reference_Manual"/>
+    <addaction name="actionIA_32_Assembly_Language_Reference_Manual"/>
     <addaction name="actionRaylib_Manual"/>
     <addaction name="actionEGE_Manual"/>
     <addaction name="separator"/>
@@ -3319,6 +3321,16 @@
     <string>GNU Assembler Manual</string>
    </property>
   </action>
+  <action name="actionx86_Assembly_Language_Reference_Manual">
+   <property name="text">
+    <string>x86 Assembly Language Reference Manual</string>
+   </property>
+  </action>
+  <action name="actionIA_32_Assembly_Language_Reference_Manual">
+   <property name="text">
+    <string>IA-32 Assembly Language Reference Manual</string>
+   </property>
+  </action>
  </widget>
  <customwidgets>
   <customwidget>

RedPandaIDE/translations/RedPandaIDE_pt_BR.ts

@@ -5040,6 +5040,14 @@
         <source>Please turn off your compiler set&apos;s &quot;Strip executable (-s)&quot; option, recompile and retry debug.</source>
         <translation type="unfinished"></translation>
     </message>
+    <message>
+        <source>x86 Assembly Language Reference Manual</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <source>IA-32 Assembly Language Reference Manual</source>
+        <translation type="unfinished"></translation>
+    </message>
 </context>
 <context>
     <name>NewClassDialog</name>
@@ -6771,7 +6779,7 @@
     </message>
     <message>
         <source>Prompt on replace</source>
-        <translation type="unfinished">Perguntar ao substituir</translation>
+        <translation type="obsolete">Perguntar ao substituir</translation>
     </message>
     <message>
         <source>Case Sensitive</source>
@@ -6850,7 +6858,7 @@
     </message>
     <message>
         <source>Prompt on replace</source>
-        <translation>Perguntar ao substituir</translation>
+        <translation type="vanished">Perguntar ao substituir</translation>
     </message>
     <message>
         <source>Scope:</source>

RedPandaIDE/translations/RedPandaIDE_zh_TW.ts

@@ -4793,6 +4793,14 @@
         <source>Please turn off your compiler set&apos;s &quot;Strip executable (-s)&quot; option, recompile and retry debug.</source>
         <translation type="unfinished"></translation>
     </message>
+    <message>
+        <source>x86 Assembly Language Reference Manual</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <source>IA-32 Assembly Language Reference Manual</source>
+        <translation type="unfinished"></translation>
+    </message>
 </context>
 <context>
     <name>NewClassDialog</name>
@@ -6350,10 +6358,6 @@
         <source>Regular Expression</source>
         <translation type="unfinished"></translation>
     </message>
-    <message>
-        <source>Prompt on replace</source>
-        <translation type="unfinished"></translation>
-    </message>
     <message>
         <source>Case Sensitive</source>
         <translation type="unfinished"></translation>
@@ -6421,10 +6425,6 @@
         <source>Wrap Around</source>
         <translation type="unfinished"></translation>
     </message>
-    <message>
-        <source>Prompt on replace</source>
-        <translation type="unfinished"></translation>
-    </message>
     <message>
         <source>Scope:</source>
         <translation type="unfinished"></translation>

RedPandaIDE/widgets/cpudialog.ui

@@ -80,7 +80,7 @@
         </widget>
        </item>
        <item>
-        <widget class="QSynedit::QSynEdit" name="txtCode">
+        <widget class="Editor" name="txtCode">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
            <horstretch>3</horstretch>
@@ -230,9 +230,9 @@
  </widget>
  <customwidgets>
   <customwidget>
-   <class>QSynedit::QSynEdit</class>
+   <class>Editor</class>
    <extends>QFrame</extends>
-   <header location="global">qsynedit/qsynedit.h</header>
+   <header>editor.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>

libs/qsynedit/qsynedit.pro

@@ -67,3 +67,6 @@ HEADERS += \
     qsynedit/syntaxer/syntaxer.h
 
 INCLUDEPATH += ../redpanda_qt_utils
+
+TRANSLATIONS += \
+    qsynedit_zh_CN.ts

libs/qsynedit/qsynedit/painter.cpp

@@ -963,8 +963,8 @@ void QSynEditPainter::paintLines()
                     sToken = edit->mSyntaxer->getToken();
                     // Maybe should also test whether GetTokenPos changed...
                     if (sToken.isEmpty()) {
-                        qDebug()<<QSynEdit::tr("The highlighter seems to be in an infinite loop");
+                        //qDebug()<<QSynEdit::tr("The highlighter seems to be in an infinite loop");
-                        throw BaseError(QSynEdit::tr("The highlighter seems to be in an infinite loop"));
+                        throw BaseError(QSynEdit::tr("The syntaxer seems to be in an infinite loop"));
                     }
                 }
                 //nTokenColumnsBefore = edit->charToColumn(sLine,edit->mHighlighter->getTokenPos()+1)-1;

libs/qsynedit/qsynedit/qsynedit.cpp

@@ -5278,33 +5278,11 @@ int QSynEdit::searchReplace(const QString &sSearch, const QString &sReplace, Sea
 void QSynEdit::doLinesDeleted(int firstLine, int count)
 {
     emit linesDeleted(firstLine, count);
-//    // gutter marks
-//    for i := 0 to Marks.Count - 1 do begin
-//      if Marks[i].Line >= FirstLine + Count then
-//        Marks[i].Line := Marks[i].Line - Count
-//      else if Marks[i].Line > FirstLine then
-//        Marks[i].Line := FirstLine;
-//    end;
-//    // plugins
-//    if fPlugins <> nil then begin
-//      for i := 0 to fPlugins.Count - 1 do
-//        TSynEditPlugin(fPlugins[i]).LinesDeleted(FirstLine, Count);
-    //    end;
 }
 
 void QSynEdit::doLinesInserted(int firstLine, int count)
 {
     emit linesInserted(firstLine, count);
-//    // gutter marks
-//    for i := 0 to Marks.Count - 1 do begin
-//      if Marks[i].Line >= FirstLine then
-//        Marks[i].Line := Marks[i].Line + Count;
-//    end;
-//    // plugins
-//    if fPlugins <> nil then begin
-//      for i := 0 to fPlugins.Count - 1 do
-//        TSynEditPlugin(fPlugins[i]).LinesInserted(FirstLine, Count);
-//    end;
 }
 
 void QSynEdit::properSetLine(int ALine, const QString &ALineText, bool notify)

libs/qsynedit/qsynedit/syntaxer/asm.cpp

@@ -20,6 +20,9 @@
 
 namespace  QSynedit {
 
+QSet<QString> ASMSyntaxer::InstructionNames;
+QMap<QString,QString> ASMSyntaxer::Instructions;
+
 const QSet<QString> ASMSyntaxer::Registers {
     "ah","al","ax","eax",
     "bh","bl","bx","ebx",
@@ -78,120 +81,6 @@ const QSet<QString> ASMSyntaxer::ATTRegisters {
     "%xmm12","%xmm13","%xmm14","%xmm15",
 };
 
-const QSet<QString> ASMSyntaxer::Instructions {
-    "aaa","aad","aam","aas","adc","adcx","add",
-    "addb","addw","addl","addq", "addpd","addps",
-    "addsd","addss","addsubpd","addsubps","adox","aesdec","aesdec128kl","aesdec256kl","aesdeclast","aesdecwide128kl",
-    "aesdecwide256kl","aesenc","aesenc128kl","aesenc256kl","aesenclast","aesencwide128kl","aesencwide256kl","aesimc","aeskeygenassist","and",
-    "andn","andnpd","andnps","andpd","andps","andb","andw","andl","andq","arpl","bextr","blendpd","blendps","blendvpd",
-    "blendvps","blsi","blsmsk","blsr","bndcl","bndcn","bndcu","bndldx","bndmk","bndmov",
-    "bndstx","bound","bsf","bsr","bswap","bt","btc","btr","bts","bzhi",
-    "call","cbw","cdq","cdqe","clac","clc","cld","cldemote","clflush","clflushopt",
-    "cli","clrssbsy","clts","clwb","cmc","cmova","cmovae","cmovb","cmovbe","cmovc",
-    "cmove","cmovg","cmovge","cmovl","cmovle","cmovna","cmovnae","cmovnb","cmovnbe","cmovnc",
-    "cmovne","cmovng","cmovnge","cmovnl","cmovnle","cmovno","cmovnp","cmovns","cmovnz","cmovo",
-    "cmovp","cmovpe","cmovpo","cmovs","cmovz","cmp","cmpb","cmpw","cmpl","cmpq",
-    "cmppd","cmpps","cmps","cmpsb", "cmpsd","cmpsq","cmpss","cmpsw","cmpxchg","cmpxchg16b","cmpxchg8b","comisd","comiss","cpuid",
-    "cqo","crc32","cvtdq2pd","cvtdq2ps","cvtpd2dq","cvtpd2pi","cvtpd2ps","cvtpi2pd","cvtpi2ps","cvtps2dq",
-    "cvtps2pd","cvtps2pi","cvtsd2si","cvtsd2ss","cvtsi2sd","cvtsi2ss","cvtss2sd","cvtss2si","cvttpd2dq","cvttpd2pi",
-    "cvttps2dq","cvttps2pi","cvttsd2si","cvttss2si","cwd","cwde","daa","das","dec","div",
-    "divpd","divps","divsd","divss","dppd","dpps","emms","encodekey128","encodekey256","endbr32",
-    "endbr64","enter","extractps","f2xm1","fabs","fadd","faddp","fbld","fbstp","fchs",
-    "fclex","fcmovb","fcmove","fcmovbe","fcmovu","fcmovnb","fcmovne","fcmovnbe","fcmovnu","fcom",
-    "fcomi","fcomip","fcomp","fcompp","fcos","fdecstp","fdiv","fdivp","fdivr","fdivrp",
-    "ffree","fiadd","ficom","ficomp","fidiv","fidivr","fild","fimul","fincstp","finit",
-    "fist","fistp","fisttp","fisub","fisubr","fld","fld1","fldcw","fldenv","fldl2e",
-    "fldl2t","fldlg2","fldln2","fldpi","fldz","fmul","fmulp","fnclex","fninit","fnop",
-    "fnsave","fnstcw","fnstenv","fnstsw","fpatan","fprem","fprem1","fptan","frndint","frstor",
-    "fsave","fscale","fsin","fsincos","fsqrt","fst","fstcw","fstenv","fstp","fstsw",
-    "fsub","fsubp","fsubr","fsubrp","ftst","fucom","fucomi","fucomip","fucomp","fucompp",
-    "fwait","fxam","fxch","fxrstor","fxsave","fxtract","fyl2x","fyl2xp1","gf2p8affineinvqb","gf2p8affineqb",
-    "gf2p8mulb","haddpd","haddps","hlt","hreset","hsubpd","hsubps","idiv","idivb","idivw","idivl","idivq","imul",
-    "imulb","imulw","imull","imulq","in",  "inc","incsspd","incsspq","ins","insb","insd","insertps","insw","int n","int1",
-    "int3","into","invd","invlpg","invpcid","iret","iretd","iretq","jmp","ja",
-    "jae","jb","jbe","jc","jcxz","je","jecxz","jg","jge","jl",
-    "jle","jna","jnae","jnb","jnbe","jnc","jne","jng","jnge","jnl",
-    "jnle","jno","jnp","jns","jnz","jo","jp","jpe","jpo","jrcxz",
-    "js","jz","kaddb","kaddd","kaddq","kaddw","kandb","kandd","kandnb","kandnd",
-    "kandnq","kandnw","kandq","kandw","kmovb","kmovd","kmovq","kmovw","knotb","knotd",
-    "knotq","knotw","korb","kord","korq","kortestb","kortestd","kortestq","kortestw","korw",
-    "kshiftlb","kshiftld","kshiftlq","kshiftlw","kshiftrb","kshiftrd","kshiftrq","kshiftrw","ktestb","ktestd",
-    "ktestq","ktestw","kunpckbw","kunpckdq","kunpckwd","kxnorb","kxnord","kxnorq","kxnorw","kxorb",
-    "kxord","kxorq","kxorw","lahf","lar","lddqu","ldmxcsr","lds","lea","leaq","leave",
-    "les","lfence","lfs","lgdt","lgs","lidt","lldt","lmsw","loadiwkey","lock",
-    "lods","lodsb","lodsd","lodsq","lodsw","loop","loope","loopne","lsl","lss",
-    "ltr","lzcnt","maskmovdqu","maskmovq","maxpd","maxps","maxsd","maxss","mfence","minpd",
-    "minps","minsd","minss","monitor","mov","movapd","movaps","movbe","movd","movddup",
-    "movdir64b","movdiri","movdq2q","movdqa","movdqu","movhlps","movhpd","movhps","movlhps","movlpd",
-    "movlps","movmskpd","movmskps","movntdq","movntdqa","movnti","movntpd","movntps","movntq","movq",
-    "movq2dq","movs","movsb","movsd","movshdup","movsldup","movsq","movss","movsw","movsx",
-    "movsxd","movupd","movups","movzx", "movb","movs","movl",
-    "mpsadbw","mul","mulpd","mulps","mulsd","mulss",
-    "mulx","mwait","neg","nop","not","or","orb","orw","orl","orq","orpd","orps","out","outs",
-    "outsb","outsd","outsw","pabsb","pabsd","pabsq","pabsw","packssdw","packsswb","packusdw",
-    "packuswb","paddb","paddd","paddq","paddsb","paddsw","paddusb","paddusw","paddw","palignr",
-    "pand","pandn","pause","pavgb","pavgw","pblendvb","pblendw","pclmulqdq","pcmpeqb","pcmpeqd",
-    "pcmpeqq","pcmpeqw","pcmpestri","pcmpestrm","pcmpgtb","pcmpgtd","pcmpgtq","pcmpgtw","pcmpistri","pcmpistrm",
-    "pconfig","pdep","pext","pextrb","pextrd","pextrq","pextrw","phaddd","phaddsw","phaddw",
-    "phminposuw","phsubd","phsubsw","phsubw","pinsrb","pinsrd","pinsrq","pinsrw","pmaddubsw","pmaddwd",
-    "pmaxsb","pmaxsd","pmaxsq","pmaxsw","pmaxub","pmaxud","pmaxuq","pmaxuw","pminsb","pminsd",
-    "pminsq","pminsw","pminub","pminud","pminuq","pminuw","pmovmskb","pmovsx","pmovzx","pmuldq",
-    "pmulhrsw","pmulhuw","pmulhw","pmulld","pmullq","pmullw","pmuludq","pop","popa","popad",
-    "popcnt","popf","popfd","popfq","popq","por","prefetchw","prefetchh","psadbw","pshufb","pshufd",
-    "pshufhw","pshuflw","pshufw","psignb","psignd","psignw","pslld","pslldq","psllq","psllw",
-    "psrad","psraq","psraw","psrld","psrldq","psrlq","psrlw","psubb","psubd","psubq",
-    "psubsb","psubsw","psubusb","psubusw","psubw","ptest","ptwrite","punpckhbw","punpckhdq","punpckhqdq",
-    "punpckhwd","punpcklbw","punpckldq","punpcklqdq","punpcklwd","push","pusha","pushad","pushf","pushfd",
-    "pushfq","pushq","pxor","rcl","rcpps","rcpss","rcr","rdfsbase","rdgsbase","rdmsr","rdpid",
-    "rdpkru","rdpmc","rdrand","rdseed","rdsspd","rdsspq","rdtsc","rdtscp","rep","repe",
-    "repne","repnz","repz","ret","rol","ror","rorx","roundpd","roundps","roundsd",
-    "roundss","rsm","rsqrtps","rsqrtss","rstorssp","sahf","sal","salb","salw","sall","salq","sar","sarb","sarw","sarl","sarq","sarx","saveprevssp",
-    "sbb","scas","scasb","scasd","scasw","serialize","setssbsy","seta","setae","setb",
-    "setbe","setc","sete","setg","setge","setl","setle","setna","setnae","setnb",
-    "setnbe","setnc","setne","setng","setnge","setnl","setnle","setno","setnp","setns",
-    "setnz","seto","setp","setpe","setpo","sets","setz","sfence","sgdt","sha1msg1",
-    "sha1msg2","sha1nexte","sha1rnds4","sha256msg1","sha256msg2","sha256rnds2","shl","shld","shlx","shr",
-    "shrd","shrx","shufpd","shufps","sidt","sldt","smsw","sqrtpd","sqrtps","sqrtsd",
-    "sqrtss","stac","stc","std","sti","stmxcsr","stos","stosb","stosd","stosq",
-    "stosw","str","sub","subpd","subps","subsd","subss","swapgs","syscall","sysenter",
-    "sysexit","sysret","test","tpause","tzcnt","ucomisd","ucomiss","ud","umonitor","umwait",
-    "unpckhpd","unpckhps","unpcklpd","unpcklps","valignd","valignq","vblendmpd","vblendmps","vbroadcast","vcompresspd",
-    "vcompressps","vcompressw","vcvtne2ps2bf16","vcvtneps2bf16","vcvtpd2qq","vcvtpd2udq","vcvtpd2uqq","vcvtph2ps","vcvtps2ph","vcvtps2qq",
-    "vcvtps2udq","vcvtps2uqq","vcvtqq2pd","vcvtqq2ps","vcvtsd2usi","vcvtss2usi","vcvttpd2qq","vcvttpd2udq","vcvttpd2uqq","vcvttps2qq",
-    "vcvttps2udq","vcvttps2uqq","vcvttsd2usi","vcvttss2usi","vcvtudq2pd","vcvtudq2ps","vcvtuqq2pd","vcvtuqq2ps","vcvtusi2sd","vcvtusi2ss",
-    "vdbpsadbw","vdpbf16ps","verr","verw","vexpandpd","vexpandps","vextractf128","vextractf32x4","vextractf32x8","vextractf64x2",
-    "vextractf64x4","vextracti128","vextracti32x4","vextracti32x8","vextracti64x2","vextracti64x4","vfixupimmpd","vfixupimmps","vfixupimmsd","vfixupimmss",
-    "vfmadd132pd","vfmadd132ps","vfmadd132sd","vfmadd132ss","vfmadd213pd","vfmadd213ps","vfmadd213sd","vfmadd213ss","vfmadd231pd","vfmadd231ps",
-    "vfmadd231sd","vfmadd231ss","vfmaddsub132pd","vfmaddsub132ps","vfmaddsub213pd","vfmaddsub213ps","vfmaddsub231pd","vfmaddsub231ps","vfmsub132pd","vfmsub132ps",
-    "vfmsub132sd","vfmsub132ss","vfmsub213pd","vfmsub213ps","vfmsub213sd","vfmsub213ss","vfmsub231pd","vfmsub231ps","vfmsub231sd","vfmsub231ss",
-    "vfmsubadd132pd","vfmsubadd132ps","vfmsubadd213pd","vfmsubadd213ps","vfmsubadd231pd","vfmsubadd231ps","vfnmadd132pd","vfnmadd132ps","vfnmadd132sd","vfnmadd132ss",
-    "vfnmadd213pd","vfnmadd213ps","vfnmadd213sd","vfnmadd213ss","vfnmadd231pd","vfnmadd231ps","vfnmadd231sd","vfnmadd231ss","vfnmsub132pd","vfnmsub132ps",
-    "vfnmsub132sd","vfnmsub132ss","vfnmsub213pd","vfnmsub213ps","vfnmsub213sd","vfnmsub213ss","vfnmsub231pd","vfnmsub231ps","vfnmsub231sd","vfnmsub231ss",
-    "vfpclasspd","vfpclassps","vfpclasssd","vfpclassss","vgatherdpd","vgatherdps","vgatherqpd","vgatherqps","vgetexppd","vgetexpps",
-    "vgetexpsd","vgetexpss","vgetmantpd","vgetmantps","vgetmantsd","vgetmantss","vinsertf128","vinsertf32x4","vinsertf32x8","vinsertf64x2",
-    "vinsertf64x4","vinserti128","vinserti32x4","vinserti32x8","vinserti64x2","vinserti64x4","vmaskmov","vmovdqa32","vmovdqa64","vmovdqu16",
-    "vmovdqu32","vmovdqu64","vmovdqu8","vp2intersectd","vp2intersectq","vpblendd","vpblendmb","vpblendmd","vpblendmq","vpblendmw",
-    "vpbroadcast","vpbroadcastb","vpbroadcastd","vpbroadcastm","vpbroadcastq","vpbroadcastw","vpcmpb","vpcmpd","vpcmpq","vpcmpub",
-    "vpcmpud","vpcmpuq","vpcmpuw","vpcmpw","vpcompressb","vpcompressd","vpcompressq","vpconflictd","vpconflictq","vpdpbusd",
-    "vpdpbusds","vpdpwssd","vpdpwssds","vperm2f128","vperm2i128","vpermb","vpermd","vpermi2b","vpermi2d","vpermi2pd",
-    "vpermi2ps","vpermi2q","vpermi2w","vpermilpd","vpermilps","vpermpd","vpermps","vpermq","vpermt2b","vpermt2d",
-    "vpermt2pd","vpermt2ps","vpermt2q","vpermt2w","vpermw","vpexpandb","vpexpandd","vpexpandq","vpexpandw","vpgatherdd",
-    "vpgatherdq","vpgatherqd","vpgatherqq","vplzcntd","vplzcntq","vpmadd52huq","vpmadd52luq","vpmaskmov","vpmovb2m","vpmovd2m",
-    "vpmovdb","vpmovdw","vpmovm2b","vpmovm2d","vpmovm2q","vpmovm2w","vpmovq2m","vpmovqb","vpmovqd","vpmovqw",
-    "vpmovsdb","vpmovsdw","vpmovsqb","vpmovsqd","vpmovsqw","vpmovswb","vpmovusdb","vpmovusdw","vpmovusqb","vpmovusqd",
-    "vpmovusqw","vpmovuswb","vpmovw2m","vpmovwb","vpmultishiftqb","vpopcnt","vprold","vprolq","vprolvd","vprolvq",
-    "vprord","vprorq","vprorvd","vprorvq","vpscatterdd","vpscatterdq","vpscatterqd","vpscatterqq","vpshld","vpshldv",
-    "vpshrd","vpshrdv","vpshufbitqmb","vpsllvd","vpsllvq","vpsllvw","vpsravd","vpsravq","vpsravw","vpsrlvd",
-    "vpsrlvq","vpsrlvw","vpternlogd","vpternlogq","vptestmb","vptestmd","vptestmq","vptestmw","vptestnmb","vptestnmd",
-    "vptestnmq","vptestnmw","vrangepd","vrangeps","vrangesd","vrangess","vrcp14pd","vrcp14ps","vrcp14sd","vrcp14ss",
-    "vreducepd","vreduceps","vreducesd","vreducess","vrndscalepd","vrndscaleps","vrndscalesd","vrndscaless","vrsqrt14pd","vrsqrt14ps",
-    "vrsqrt14sd","vrsqrt14ss","vscalefpd","vscalefps","vscalefsd","vscalefss","vscatterdpd","vscatterdps","vscatterqpd","vscatterqps",
-    "vshuff32x4","vshuff64x2","vshufi32x4","vshufi64x2","vtestpd","vtestps","vzeroall","vzeroupper","wait","wbinvd",
-    "wbnoinvd","wrfsbase","wrgsbase","wrmsr","wrpkru","wrssd","wrssq","wrussd","wrussq","xabort",
-    "xacquire","xadd","xbegin","xchg","xend","xgetbv","xlat","xlatb","xor","xorb","xorw","xorl","xorq","xorpd",
-    "xorps","xrelease","xrstor","xrstors","xsave","xsavec","xsaveopt","xsaves","xsetbv","xtest",
-};
-
 const QSet<QString> ASMSyntaxer::Directives {
     "section","global","extern","segment",
     "db","dw","dd","dq","dt","do","dy","dz",
@@ -233,6 +122,7 @@ const QSet<QString> ASMSyntaxer::ATTDirectives {
 ASMSyntaxer::ASMSyntaxer(bool isATT):
     mATT(isATT)
 {
+    initData();
     mNumberAttribute = std::make_shared<TokenAttribute>(SYNS_AttrNumber, TokenType::Number);
     addAttribute(mNumberAttribute);
     mDirectiveAttribute = std::make_shared<TokenAttribute>(SYNS_AttrVariable, TokenType::Keyword);
@@ -440,6 +330,766 @@ bool ASMSyntaxer::isIdentStartChar(const QChar &ch)
     return false;
 }
 
+void ASMSyntaxer::initData()
+{
+    if (Instructions.isEmpty()) {
+        // https://docs.oracle.com/cd/E19120-01/open.solaris/817-5477/ennbz/index.html
+        //Data Transfer Instruction
+        Instructions.insert("bswap",QObject::tr("byte swap."));
+        Instructions.insert("bswapl",QObject::tr("byte swap."));
+        Instructions.insert("bswapq",QObject::tr("byte swap."));
+        Instructions.insert("cbtw",QObject::tr("convert %1 to %2.").arg(QObject::tr("byte"),QObject::tr("word")));
+        Instructions.insert("cltd",QObject::tr("convert %1 in %2 to %3 in %4.").arg(QObject::tr("double word"),"%eax",QObject::tr("quad word"),"%edx:%eax"));
+        Instructions.insert("cltq",QObject::tr("convert %1 in %2 to %3 in %4.").arg(QObject::tr("double word"),"%eax",QObject::tr("quad word"),"%rax"));
+        Instructions.insert("cmove",QObject::tr("Conditional move if equal"));
+        Instructions.insert("cmovz",QObject::tr("Conditional move if zero."));
+        Instructions.insert("cmovne",QObject::tr("Conditional move if not equal."));
+        Instructions.insert("cmovnz",QObject::tr("Conditional move if not equal."));
+        Instructions.insert("cmova",QObject::tr("Conditional move if above."));
+        Instructions.insert("cmovbe",QObject::tr("Conditional move if not below or equal."));
+        Instructions.insert("cmovae",QObject::tr("Conditional move if above or equal."));
+        Instructions.insert("cmovnb",QObject::tr("Conditional move if not below."));
+        Instructions.insert("cmovb",QObject::tr("Conditional move if below."));
+        Instructions.insert("cmovnae",QObject::tr("Conditional move if not above or equal."));
+        Instructions.insert("cmovbe",QObject::tr("Conditional move if below or equal."));
+        Instructions.insert("cmovna",QObject::tr("Conditional move if not above."));
+        Instructions.insert("cmovg",QObject::tr("Conditional move if greater."));
+        Instructions.insert("cmovnle",QObject::tr("Conditional move if not less or equal."));
+        Instructions.insert("cmovge",QObject::tr("Conditional move if greater or equal."));
+        Instructions.insert("cmovnl",QObject::tr("Conditional move if not less."));
+        Instructions.insert("cmovl",QObject::tr("Conditional move if less."));
+        Instructions.insert("cmovnge",QObject::tr("Conditional move if not greater or equal."));
+        Instructions.insert("cmovle",QObject::tr("Conditional move if less or equal."));
+        Instructions.insert("cmovng",QObject::tr("Conditional move if not greater."));
+        Instructions.insert("cmovc",QObject::tr("Conditional move if carry."));
+        Instructions.insert("cmovnc",QObject::tr("Conditional move if not carry."));
+        Instructions.insert("cmovo",QObject::tr("Conditional move if overflow."));
+        Instructions.insert("cmovno",QObject::tr("Conditional move if not overflow."));
+        Instructions.insert("cmovs",QObject::tr("Conditional move if sign (negative)."));
+        Instructions.insert("cmovns",QObject::tr("Conditional move if not sign (non-negative)."));
+        Instructions.insert("cmovp",QObject::tr("Conditional move if parity."));
+        Instructions.insert("cmovpe",QObject::tr("Conditional move if parity even."));
+        Instructions.insert("cmovnp",QObject::tr("Conditional move if not parity."));
+        Instructions.insert("cmovpo",QObject::tr("Conditional move if parity odd."));
+        Instructions.insert("cmpxchg",QObject::tr("Compare and exchange."));
+        Instructions.insert("cmpxchg8b",QObject::tr("Compare and exchange 8 bytes."));
+        Instructions.insert("cqtd",QObject::tr("convert %1 in %2 to %3 in %4.").arg(QObject::tr("quad word"),"%rax",QObject::tr("oct word"),"%rdx:%rax"));
+        Instructions.insert("cqto",QObject::tr("convert %1 in %2 to %3 in %4.").arg(QObject::tr("quad word"),"%rax",QObject::tr("oct word"),"%rdx:%rax"));
+        Instructions.insert("cwtd",QObject::tr("convert %1 in %2 to %3 in %4.").arg(QObject::tr("word"),"%ax",QObject::tr("double word"),"%dx:%ax"));
+        Instructions.insert("cwtl",QObject::tr("convert %1 in %2 to %3 in %4.").arg(QObject::tr("word"),"%ax",QObject::tr("double word"),"%eax"));
+        Instructions.insert("mov",QObject::tr("move data between immediate values, general purpose registers, segment registers, and memory."));
+        Instructions.insert("movb",QObject::tr("move %1 data between immediate values, general purpose registers, segment registers, and memory.").arg(QObject::tr("byte")));
+        Instructions.insert("movw",QObject::tr("Move %1.").arg(QObject::tr("word")));
+        Instructions.insert("movl",QObject::tr("Move %1.").arg(QObject::tr("double word")));
+        Instructions.insert("movq",QObject::tr("Move %1.").arg(QObject::tr("quad word")));
+        Instructions.insert("movabs",QObject::tr("move immediate value to register."));
+        Instructions.insert("movabsb",QObject::tr("move immediate %1 value to register.").arg(QObject::tr("byte")));
+        Instructions.insert("movabsw",QObject::tr("move immediate %1 value to register.").arg(QObject::tr("word")));
+        Instructions.insert("movabsl",QObject::tr("move immediate %1 value to register.").arg(QObject::tr("double word")));
+        Instructions.insert("movabsq",QObject::tr("move immediate %1 value to register.").arg(QObject::tr("quad word")));
+        Instructions.insert("movabsa",QObject::tr("move immediate value to register %al/%ax/%eax/%rax."));
+        Instructions.insert("movabsba",QObject::tr("move immediate %1 value to register %2.").arg(QObject::tr("byte"),"%al"));
+        Instructions.insert("movabswa",QObject::tr("move immediate %1 value to register %2.").arg(QObject::tr("word"),"%ax"));
+        Instructions.insert("movabsla",QObject::tr("move immediate %1 value to register %2.").arg(QObject::tr("double word"),"%eax"));
+        Instructions.insert("movabsqa",QObject::tr("move immediate %1 value to register %2.").arg(QObject::tr("quad word"),"%rax"));
+        Instructions.insert("movsx",QObject::tr("Move and sign extension.")); //intel
+        Instructions.insert("movsbw",QObject::tr("Move sign-extended %1 to %2.").arg(QObject::tr("byte"),QObject::tr("word")));
+        Instructions.insert("movsbl",QObject::tr("Move sign-extended %1 to %2.").arg(QObject::tr("byte"),QObject::tr("double word")));
+        Instructions.insert("movswl",QObject::tr("Move sign-extended %1 to %2.").arg(QObject::tr("word"),QObject::tr("double word")));
+        Instructions.insert("movsbq",QObject::tr("Move sign-extended %1 to %2.").arg(QObject::tr("byte"),QObject::tr("quad word")));
+        Instructions.insert("movswq",QObject::tr("Move sign-extended %1 to %2.").arg(QObject::tr("word"),QObject::tr("quad word")));
+        Instructions.insert("movslq",QObject::tr("Move sign-extended %1 to %2.").arg(QObject::tr("double word"),QObject::tr("quad word")));
+        Instructions.insert("movzx",QObject::tr("Move with zero extension.")); //intel
+        Instructions.insert("movzbw",QObject::tr("Move zero-extended %1 to %2.").arg(QObject::tr("byte"),QObject::tr("word")));
+        Instructions.insert("movzbl",QObject::tr("Move zero-extended %1 to %2.").arg(QObject::tr("byte"),QObject::tr("double word")));
+        Instructions.insert("movzwl",QObject::tr("Move zero-extended %1 to %2.").arg(QObject::tr("word"),QObject::tr("double word")));
+        Instructions.insert("movzbq",QObject::tr("Move zero-extended %1 to %2.").arg(QObject::tr("byte"),QObject::tr("quad word")));
+        Instructions.insert("movzwq",QObject::tr("Move zero-extended %1 to %2.").arg(QObject::tr("word"),QObject::tr("quad word")));
+        Instructions.insert("pop",QObject::tr("Pop stack."));
+        Instructions.insert("popw",QObject::tr("Pop %1 off stack.").arg(QObject::tr("word")));
+        Instructions.insert("popl",QObject::tr("Pop %1 off stack.").arg(QObject::tr("double word")));
+        Instructions.insert("popq",QObject::tr("Pop %1 off stack.").arg(QObject::tr("quad word")));
+        Instructions.insert("popa",QObject::tr("Pop general-purpose registers from stack."));
+        Instructions.insert("popaw",QObject::tr("Pop general-purpose registers from stack."));
+        Instructions.insert("popad",QObject::tr("Pop general-purpose registers from stack."));
+        Instructions.insert("push",QObject::tr("Push stack."));
+        Instructions.insert("pushw",QObject::tr("Push %1 onto stack.").arg(QObject::tr("word")));
+        Instructions.insert("pushl",QObject::tr("Push %1 onto stack.").arg(QObject::tr("double word")));
+        Instructions.insert("pushq",QObject::tr("Push %1 onto stack.").arg(QObject::tr("quad word")));
+        Instructions.insert("pusha",QObject::tr("Push general-purpose registers onto stack."));
+        Instructions.insert("pushaw",QObject::tr("Push general-purpose registers onto stack."));
+        Instructions.insert("pushal",QObject::tr("Push general-purpose registers onto stack."));
+        Instructions.insert("xadd",QObject::tr("Exchange and add %1.").arg("integer"));
+        Instructions.insert("xaddb",QObject::tr("Exchange and add %1.").arg("byte"));
+        Instructions.insert("xaddw",QObject::tr("Exchange and add %1.").arg("word"));
+        Instructions.insert("xaddl",QObject::tr("Exchange and add %1.").arg("double word"));
+        Instructions.insert("xaddq",QObject::tr("Exchange and add %1.").arg("quad word"));
+        Instructions.insert("xchg",QObject::tr("Exchange %1.").arg("integer"));
+        Instructions.insert("xchgb",QObject::tr("Exchange %1.").arg("byte"));
+        Instructions.insert("xchgw",QObject::tr("Exchange %1.").arg("word"));
+        Instructions.insert("xchgl",QObject::tr("Exchange %1.").arg("double word"));
+        Instructions.insert("xchgq",QObject::tr("Exchange %1.").arg("quad word"));
+        //Binary Arithmetic Instructions
+        Instructions.insert("adcx",QObject::tr("add unsigned %1 with carry.").arg(QObject::tr("integer"))); //intel
+//        Instructions.insert("adcxb",QObject::tr("add unsigned %1 with carry.").arg(QObject::tr("byte")));
+//        Instructions.insert("adcxw",QObject::tr("add unsigned %1 with carry.").arg(QObject::tr("word")));
+//        Instructions.insert("adcxl",QObject::tr("add unsigned %1 with carry.").arg(QObject::tr("double word")));
+//        Instructions.insert("adcxq",QObject::tr("add unsigned %1 with carry.").arg(QObject::tr("quad word")));
+        Instructions.insert("ado",QObject::tr("add unsigned %1 with overflow.").arg(QObject::tr("integer"))); //intel
+//        Instructions.insert("adob",QObject::tr("add unsigned %1 with overflow.").arg(QObject::tr("byte")));
+//        Instructions.insert("adow",QObject::tr("add unsigned %1 with overflow.").arg(QObject::tr("word")));
+//        Instructions.insert("adol",QObject::tr("add unsigned %1 with overflow.").arg(QObject::tr("double word")));
+//        Instructions.insert("adoq",QObject::tr("add unsigned %1 with overflow.").arg(QObject::tr("quad word")));
+        Instructions.insert("adc",QObject::tr("add %1 with carry.").arg(QObject::tr("integer")));
+        Instructions.insert("adcb",QObject::tr("add %1 with carry.").arg(QObject::tr("byte")));
+        Instructions.insert("adcw",QObject::tr("add %1 with carry.").arg(QObject::tr("word")));
+        Instructions.insert("adcl",QObject::tr("add %1 with carry.").arg(QObject::tr("double word")));
+        Instructions.insert("adcq",QObject::tr("add %1 with carry.").arg(QObject::tr("quad word")));
+        Instructions.insert("add",QObject::tr("add %1.").arg(QObject::tr("integer")));
+        Instructions.insert("addb",QObject::tr("add %1.").arg(QObject::tr("byte")));
+        Instructions.insert("addw",QObject::tr("add %1.").arg(QObject::tr("word")));
+        Instructions.insert("addl",QObject::tr("add %1.").arg(QObject::tr("double word")));
+        Instructions.insert("addq",QObject::tr("add %1.").arg(QObject::tr("quad word")));
+        Instructions.insert("cmp",QObject::tr("compare."));
+        Instructions.insert("cmpb",QObject::tr("compare %1.").arg(QObject::tr("byte")));
+        Instructions.insert("cmpw",QObject::tr("compare %1.").arg(QObject::tr("word")));
+        Instructions.insert("cmpl",QObject::tr("compare %1.").arg(QObject::tr("double word")));
+        Instructions.insert("cmpq",QObject::tr("compare %1.").arg(QObject::tr("quad word")));
+        Instructions.insert("dec",QObject::tr("decrement by 1."));
+        Instructions.insert("decb",QObject::tr("decrement %1 by 1.").arg(QObject::tr("byte")));
+        Instructions.insert("decw",QObject::tr("decrement %1 by 1.").arg(QObject::tr("word")));
+        Instructions.insert("decl",QObject::tr("decrement %1 by 1.").arg(QObject::tr("double word")));
+        Instructions.insert("decq",QObject::tr("decrement %1 by 1.").arg(QObject::tr("quad word")));
+        Instructions.insert("div",QObject::tr("unsigned %1 divide.").arg(QObject::tr("integer")));
+        Instructions.insert("divb",QObject::tr("unsigned %1 divide.").arg(QObject::tr("byte")));
+        Instructions.insert("divw",QObject::tr("unsigned %1 divide.").arg(QObject::tr("word")));
+        Instructions.insert("divl",QObject::tr("unsigned %1 divide.").arg(QObject::tr("double word")));
+        Instructions.insert("divq",QObject::tr("unsigned %1 divide.").arg(QObject::tr("quad word")));
+        Instructions.insert("idiv",QObject::tr("signed %1 divide.").arg(QObject::tr("integer")));
+        Instructions.insert("idivb",QObject::tr("signed %1 divide.").arg(QObject::tr("byte")));
+        Instructions.insert("idivw",QObject::tr("signed %1 divide.").arg(QObject::tr("word")));
+        Instructions.insert("idivl",QObject::tr("signed %1 divide.").arg(QObject::tr("double word")));
+        Instructions.insert("idivq",QObject::tr("signed %1 divide.").arg(QObject::tr("quad word")));
+        Instructions.insert("imul",QObject::tr("signed %1 multiply.").arg(QObject::tr("integer")));
+        Instructions.insert("imulb",QObject::tr("signed %1 multiply.").arg(QObject::tr("byte")));
+        Instructions.insert("imulw",QObject::tr("signed %1 multiply.").arg(QObject::tr("word")));
+        Instructions.insert("imull",QObject::tr("signed %1 multiply.").arg(QObject::tr("double word")));
+        Instructions.insert("imulq",QObject::tr("signed %1 multiply.").arg(QObject::tr("quad word")));
+        Instructions.insert("inc",QObject::tr("increment by 1."));
+        Instructions.insert("incb",QObject::tr("increment %1 by 1.").arg(QObject::tr("byte")));
+        Instructions.insert("incw",QObject::tr("increment %1 by 1.").arg(QObject::tr("word")));
+        Instructions.insert("incl",QObject::tr("increment %1 by 1.").arg(QObject::tr("double word")));
+        Instructions.insert("incq",QObject::tr("increment %1 by 1.").arg(QObject::tr("quad word")));
+        Instructions.insert("mul",QObject::tr("unsigned %1 multiply.").arg(QObject::tr("integer")));
+        Instructions.insert("mulb",QObject::tr("unsigned %1 multiply.").arg(QObject::tr("byte")));
+        Instructions.insert("mulw",QObject::tr("unsigned %1 multiply.").arg(QObject::tr("word")));
+        Instructions.insert("mull",QObject::tr("unsigned %1 multiply.").arg(QObject::tr("double word")));
+        Instructions.insert("mulq",QObject::tr("unsigned %1 multiply.").arg(QObject::tr("quad word")));
+        Instructions.insert("neg",QObject::tr("Two's complement negation."));
+        Instructions.insert("negb",QObject::tr("Replace the value of the %1 with its two's complement").arg("byte"));
+        Instructions.insert("negw",QObject::tr("Replace the value of the %1 with its two's complement").arg("word"));
+        Instructions.insert("negl",QObject::tr("Replace the value of the %1 with its two's complement").arg("double word"));
+        Instructions.insert("negq",QObject::tr("Replace the value of the %1 with its two's complement").arg("quad word"));
+        Instructions.insert("sbb",QObject::tr("subtract %1 with borrow.").arg(QObject::tr("integer")));
+        Instructions.insert("sbbb",QObject::tr("subtract %1 with borrow.").arg(QObject::tr("byte")));
+        Instructions.insert("sbbw",QObject::tr("subtract %1 with borrow.").arg(QObject::tr("word")));
+        Instructions.insert("sbbl",QObject::tr("subtract %1 with borrow.").arg(QObject::tr("double word")));
+        Instructions.insert("sbbq",QObject::tr("subtract %1 with borrow.").arg(QObject::tr("quad word")));
+        Instructions.insert("sub",QObject::tr("subtract %1.").arg(QObject::tr("integer")));
+        Instructions.insert("subb",QObject::tr("subtract %1.").arg(QObject::tr("byte")));
+        Instructions.insert("subw",QObject::tr("subtract %1.").arg(QObject::tr("word")));
+        Instructions.insert("subl",QObject::tr("subtract %1.").arg(QObject::tr("double word")));
+        Instructions.insert("subq",QObject::tr("subtract %1.").arg(QObject::tr("quad word")));
+        //Decimal Arithmetic Instructions
+        Instructions.insert("aaa",QObject::tr("ascii adjust after addition."));
+        Instructions.insert("aad",QObject::tr("ascii adjust before division."));
+        Instructions.insert("aam",QObject::tr("ascii adjust after multiplication."));
+        Instructions.insert("aas",QObject::tr("ascii adjust after subtraction."));
+        Instructions.insert("daa",QObject::tr("decimal adjust after addition."));
+        Instructions.insert("das",QObject::tr("decimal adjust after subtraction."));
+        //Logical Instructions
+        Instructions.insert("and",QObject::tr("bitwise logical AND."));
+        Instructions.insert("andb",QObject::tr("bitwise logical AND on %1 values.").arg(QObject::tr("byte")));
+        Instructions.insert("andw",QObject::tr("bitwise logical AND on %1 values.").arg(QObject::tr("word")));
+        Instructions.insert("andl",QObject::tr("bitwise logical AND on %1 values.").arg(QObject::tr("double word")));
+        Instructions.insert("andq",QObject::tr("bitwise logical AND on %1 values.").arg(QObject::tr("quad word")));
+        Instructions.insert("not",QObject::tr("bitwise logical NOT."));
+        Instructions.insert("notb",QObject::tr("bitwise logical NOT on %1 value.").arg(QObject::tr("byte")));
+        Instructions.insert("notw",QObject::tr("bitwise logical NOT on %1 value.").arg(QObject::tr("word")));
+        Instructions.insert("notl",QObject::tr("bitwise logical NOT on %1 value.").arg(QObject::tr("double word")));
+        Instructions.insert("notq",QObject::tr("bitwise logical NOT on %1 value.").arg(QObject::tr("quad word")));
+        Instructions.insert("or",QObject::tr("bitwise logical OR."));
+        Instructions.insert("orb",QObject::tr("bitwise logical OR on %1 values.").arg(QObject::tr("byte")));
+        Instructions.insert("orw",QObject::tr("bitwise logical OR on %1 values.").arg(QObject::tr("word")));
+        Instructions.insert("orl",QObject::tr("bitwise logical OR on %1 values.").arg(QObject::tr("double word")));
+        Instructions.insert("orq",QObject::tr("bitwise logical OR on %1 values.").arg(QObject::tr("quad word")));
+        Instructions.insert("xor",QObject::tr("bitwise logical XOR."));
+        Instructions.insert("xorb",QObject::tr("bitwise logical XOR on %1 values.").arg(QObject::tr("byte")));
+        Instructions.insert("xorw",QObject::tr("bitwise logical XOR on %1 values.").arg(QObject::tr("word")));
+        Instructions.insert("xorl",QObject::tr("bitwise logical XOR on %1 values.").arg(QObject::tr("double word")));
+        Instructions.insert("xorq",QObject::tr("bitwise logical XOR on %1 values.").arg(QObject::tr("quad word")));
+        //Shift and Rotate Instructions
+        Instructions.insert("rcl",QObject::tr("rotate %1 through carry left.").arg(QObject::tr("integer")));
+        Instructions.insert("rclb",QObject::tr("rotate %1 through carry left.").arg(QObject::tr("byte")));
+        Instructions.insert("rclw",QObject::tr("rotate %1 through carry left.").arg(QObject::tr("word")));
+        Instructions.insert("rcll",QObject::tr("rotate %1 through carry left.").arg(QObject::tr("double word")));
+        Instructions.insert("rclq",QObject::tr("rotate %1 through carry left.").arg(QObject::tr("quad word")));
+        Instructions.insert("rcr",QObject::tr("rotate %1 through carry right.").arg(QObject::tr("integer")));
+        Instructions.insert("rcrb",QObject::tr("rotate %1 through carry right.").arg(QObject::tr("byte")));
+        Instructions.insert("rcrw",QObject::tr("rotate %1 through carry right.").arg(QObject::tr("word")));
+        Instructions.insert("rcrl",QObject::tr("rotate %1 through carry right.").arg(QObject::tr("double word")));
+        Instructions.insert("rcrq",QObject::tr("rotate %1 through carry right.").arg(QObject::tr("quad word")));
+        Instructions.insert("rol",QObject::tr("rotate %1 left.").arg(QObject::tr("integer")));
+        Instructions.insert("rolb",QObject::tr("rotate %1 left.").arg(QObject::tr("byte")));
+        Instructions.insert("rolw",QObject::tr("rotate %1 left.").arg(QObject::tr("word")));
+        Instructions.insert("roll",QObject::tr("rotate %1 left.").arg(QObject::tr("double word")));
+        Instructions.insert("rolq",QObject::tr("rotate %1 left.").arg(QObject::tr("quad word")));
+        Instructions.insert("ror",QObject::tr("rotate %1 right.").arg(QObject::tr("integer")));
+        Instructions.insert("rorb",QObject::tr("rotate %1 right.").arg(QObject::tr("byte")));
+        Instructions.insert("rorw",QObject::tr("rotate %1 right.").arg(QObject::tr("word")));
+        Instructions.insert("rorl",QObject::tr("rotate %1 right.").arg(QObject::tr("double word")));
+        Instructions.insert("rorq",QObject::tr("rotate %1 right.").arg(QObject::tr("quad word")));
+        Instructions.insert("sal",QObject::tr("shift %1 arithmetic left.").arg(QObject::tr("integer")));
+        Instructions.insert("salb",QObject::tr("shift %1 arithmetic left.").arg(QObject::tr("byte")));
+        Instructions.insert("salw",QObject::tr("shift %1 arithmetic left.").arg(QObject::tr("word")));
+        Instructions.insert("sall",QObject::tr("shift %1 arithmetic left.").arg(QObject::tr("double word")));
+        Instructions.insert("salq",QObject::tr("shift %1 arithmetic left.").arg(QObject::tr("quad word")));
+        Instructions.insert("sar",QObject::tr("shift %1 arithmetic right.").arg(QObject::tr("integer")));
+        Instructions.insert("sarb",QObject::tr("shift %1 arithmetic right.").arg(QObject::tr("byte")));
+        Instructions.insert("sarw",QObject::tr("shift %1 arithmetic right.").arg(QObject::tr("word")));
+        Instructions.insert("sarl",QObject::tr("shift %1 arithmetic right.").arg(QObject::tr("double word")));
+        Instructions.insert("sarq",QObject::tr("shift %1 arithmetic right.").arg(QObject::tr("quad word")));
+        Instructions.insert("shl",QObject::tr("shift %1 logical left.").arg(QObject::tr("integer")));
+        Instructions.insert("shlb",QObject::tr("shift %1 logical left.").arg(QObject::tr("byte")));
+        Instructions.insert("shlw",QObject::tr("shift %1 logical left.").arg(QObject::tr("word")));
+        Instructions.insert("shll",QObject::tr("shift %1 logical left.").arg(QObject::tr("double word")));
+        Instructions.insert("shlq",QObject::tr("shift %1 logical left.").arg(QObject::tr("quad word")));
+        Instructions.insert("shr",QObject::tr("shift %1 logical right.").arg(QObject::tr("integer")));
+        Instructions.insert("shrb",QObject::tr("shift %1 logical right.").arg(QObject::tr("byte")));
+        Instructions.insert("shrw",QObject::tr("shift %1 logical right.").arg(QObject::tr("word")));
+        Instructions.insert("shrl",QObject::tr("shift %1 logical right.").arg(QObject::tr("double word")));
+        Instructions.insert("shrq",QObject::tr("shift %1 logical right.").arg(QObject::tr("quad word")));
+        Instructions.insert("shld",QObject::tr("shift %1 left double.").arg(QObject::tr("integer")));
+        Instructions.insert("shldb",QObject::tr("shift %1 left double.").arg(QObject::tr("byte")));
+        Instructions.insert("shldw",QObject::tr("shift %1 left double.").arg(QObject::tr("word")));
+        Instructions.insert("shldl",QObject::tr("shift %1 left double.").arg(QObject::tr("double word")));
+        Instructions.insert("shldq",QObject::tr("shift %1 left double.").arg(QObject::tr("quad word")));
+        Instructions.insert("shrd",QObject::tr("shift %1 right double.").arg(QObject::tr("integer")));
+        Instructions.insert("shrdb",QObject::tr("shift %1 right double.").arg(QObject::tr("byte")));
+        Instructions.insert("shrdw",QObject::tr("shift %1 right double.").arg(QObject::tr("word")));
+        Instructions.insert("shrdl",QObject::tr("shift %1 right double.").arg(QObject::tr("double word")));
+        Instructions.insert("shrdq",QObject::tr("shift %1 right double.").arg(QObject::tr("quad word")));
+        //Bit and Byte Instructions
+        Instructions.insert("bsf",QObject::tr("bit scan forward."));
+        Instructions.insert("bsfw",QObject::tr("bit scan forward in the %1 operand.").arg(QObject::tr("word")));
+        Instructions.insert("bsfl",QObject::tr("bit scan forward in the %1 operand.").arg(QObject::tr("double word")));
+        Instructions.insert("bsfq",QObject::tr("bit scan forward in the %1 operand.").arg(QObject::tr("quad word")));
+        Instructions.insert("bsr",QObject::tr("bit scan reserve."));
+        Instructions.insert("bsrw",QObject::tr("bit scan reserve in the %1 operand.").arg(QObject::tr("word")));
+        Instructions.insert("bsrl",QObject::tr("bit scan reserve in the %1 operand.").arg(QObject::tr("double word")));
+        Instructions.insert("bsrq",QObject::tr("bit scan reserve in the %1 operand.").arg(QObject::tr("quad word")));
+        Instructions.insert("bt",QObject::tr("bit test."));
+        Instructions.insert("btw",QObject::tr("bit test in the %1 operand.").arg(QObject::tr("word")));
+        Instructions.insert("btl",QObject::tr("bit test in the %1 operand.").arg(QObject::tr("double word")));
+        Instructions.insert("btq",QObject::tr("bit test in the %1 operand.").arg(QObject::tr("quad word")));
+        Instructions.insert("btc",QObject::tr("bit test and complement."));
+        Instructions.insert("btcw",QObject::tr("bit test and complement in the %1 operand.").arg(QObject::tr("word")));
+        Instructions.insert("btcl",QObject::tr("bit test and complement in the %1 operand.").arg(QObject::tr("double word")));
+        Instructions.insert("btcq",QObject::tr("bit test and complement in the %1 operand.").arg(QObject::tr("quad word")));
+        Instructions.insert("btr",QObject::tr("bit test and reset."));
+        Instructions.insert("btrw",QObject::tr("bit test and reset in the %1 operand.").arg(QObject::tr("word")));
+        Instructions.insert("btrl",QObject::tr("bit test and reset in the %1 operand.").arg(QObject::tr("double word")));
+        Instructions.insert("btrq",QObject::tr("bit test and reset in the %1 operand.").arg(QObject::tr("quad word")));
+        Instructions.insert("bts",QObject::tr("bit test and set."));
+        Instructions.insert("btsw",QObject::tr("bit test and set in the %1 operand.").arg(QObject::tr("word")));
+        Instructions.insert("btsl",QObject::tr("bit test and set in the %1 operand.").arg(QObject::tr("double word")));
+        Instructions.insert("btsq",QObject::tr("bit test and set in the %1 operand.").arg(QObject::tr("quad word")));
+        Instructions.insert("seta",QObject::tr("set byte if above."));
+        Instructions.insert("setae",QObject::tr("set byte if above or equal."));
+        Instructions.insert("setb",QObject::tr("set byte if below."));
+        Instructions.insert("setbe",QObject::tr("set byte if below or equal."));
+        Instructions.insert("setc",QObject::tr("set byte if carry."));
+        Instructions.insert("sete",QObject::tr("set byte if equal."));
+        Instructions.insert("setg",QObject::tr("set byte if greater."));
+        Instructions.insert("setge",QObject::tr("set byte if greater or equal."));
+        Instructions.insert("setl",QObject::tr("set byte if less."));
+        Instructions.insert("setle",QObject::tr("set byte if less or equal."));
+        Instructions.insert("setna",QObject::tr("set byte if not above."));
+        Instructions.insert("setnae",QObject::tr("set byte if not above or equal."));
+        Instructions.insert("setnb",QObject::tr("set byte if not below."));
+        Instructions.insert("setnbe",QObject::tr("set byte if not below or equal."));
+        Instructions.insert("setnc",QObject::tr("set byte if not carry."));
+        Instructions.insert("setne",QObject::tr("set byte if not equal."));
+        Instructions.insert("setng",QObject::tr("set byte if not greater."));
+        Instructions.insert("setnge",QObject::tr("set byte if not greater or equal."));
+        Instructions.insert("setnl",QObject::tr("set byte if not less."));
+        Instructions.insert("setnle",QObject::tr("set byte if not less or equal."));
+        Instructions.insert("setno",QObject::tr("set byte if not overflow."));
+        Instructions.insert("setnp",QObject::tr("set byte if not parity."));
+        Instructions.insert("setns",QObject::tr("set byte if not sign (non-negative)."));
+        Instructions.insert("setnz",QObject::tr("set byte if not zero."));
+        Instructions.insert("seto",QObject::tr("set byte if overflow."));
+        Instructions.insert("setp",QObject::tr("set byte if parity."));
+        Instructions.insert("setpe",QObject::tr("set byte if parity even."));
+        Instructions.insert("setpo",QObject::tr("set byte if parity odd."));
+        Instructions.insert("sets",QObject::tr("set byte if sign (negative)."));
+        Instructions.insert("setz",QObject::tr("set byte if zero."));
+        Instructions.insert("test",QObject::tr("logical compare."));
+        Instructions.insert("testb",QObject::tr("logical compare %1.").arg(QObject::tr("byte")));
+        Instructions.insert("testw",QObject::tr("logical compare %1.").arg(QObject::tr("word")));
+        Instructions.insert("testl",QObject::tr("logical compare %1.").arg(QObject::tr("double word")));
+        Instructions.insert("testq",QObject::tr("logical compare %1.").arg(QObject::tr("quad word")));
+
+        //Control Transfer Instructions
+        Instructions.insert("bound",QObject::tr("detect value out of range."));
+        Instructions.insert("boundw",QObject::tr("detect %1 value out of range.").arg(QObject::tr("word")));
+        Instructions.insert("boundl",QObject::tr("detect %1 value out of range.").arg(QObject::tr("double word")));
+        Instructions.insert("call",QObject::tr("call procedure."));
+        Instructions.insert("enter",QObject::tr("high-level procedure entry."));
+        Instructions.insert("int",QObject::tr("software interrupt."));
+        Instructions.insert("into",QObject::tr("interrupt on overflow."));
+        Instructions.insert("iret",QObject::tr("return from interrupt."));
+        Instructions.insert("ja",QObject::tr("jump if above."));
+        Instructions.insert("jae",QObject::tr("jump if above or equal."));
+        Instructions.insert("jb",QObject::tr("jump if below."));
+        Instructions.insert("jbe",QObject::tr("jump if below or equal."));
+        Instructions.insert("jc",QObject::tr("jump if carry."));
+        Instructions.insert("jcxz",QObject::tr("jump register %cx zero"));
+        Instructions.insert("je",QObject::tr("jump if equal."));
+        Instructions.insert("jecxz",QObject::tr("jump register %ecx zero"));
+        Instructions.insert("jg",QObject::tr("jump if greater."));
+        Instructions.insert("jge",QObject::tr("jump if greater or equal."));
+        Instructions.insert("jl",QObject::tr("jump if less."));
+        Instructions.insert("jle",QObject::tr("jump if less or equal."));
+        Instructions.insert("jmp",QObject::tr("jump."));
+        Instructions.insert("jnae",QObject::tr("jump if not above or equal."));
+        Instructions.insert("jnb",QObject::tr("jump if not below."));
+        Instructions.insert("jnbe",QObject::tr("jump if not below or equal."));
+        Instructions.insert("jnc",QObject::tr("jump if not carry."));
+        Instructions.insert("jne",QObject::tr("jump if not equal."));
+        Instructions.insert("jng",QObject::tr("jump if not greater."));
+        Instructions.insert("jnge",QObject::tr("jump if not greater or equal."));
+        Instructions.insert("jnl",QObject::tr("jump if not less."));
+        Instructions.insert("jnle",QObject::tr("jump if not less or equal."));
+        Instructions.insert("jno",QObject::tr("jump if not overflow."));
+        Instructions.insert("jnp",QObject::tr("jump if not parity."));
+        Instructions.insert("jns",QObject::tr("jump if not sign (non-negative)."));
+        Instructions.insert("jnz",QObject::tr("jump if not zero."));
+        Instructions.insert("jo",QObject::tr("jump if overflow."));
+        Instructions.insert("jp",QObject::tr("jump if parity."));
+        Instructions.insert("jpe",QObject::tr("jump if parity even."));
+        Instructions.insert("jpo",QObject::tr("jump if parity odd."));
+        Instructions.insert("js",QObject::tr("jump if sign (negative)."));
+        Instructions.insert("jz",QObject::tr("jump if zero."));
+        Instructions.insert("lcall",QObject::tr("call far procedure."));
+        Instructions.insert("leave",QObject::tr("high-level procedure exit."));
+        Instructions.insert("loop",QObject::tr("loop with %ecx counter"));
+        Instructions.insert("loope",QObject::tr("loop with %ecx and equal"));
+        Instructions.insert("loopne",QObject::tr("loop with %ecx and not equal"));
+        Instructions.insert("loopnz",QObject::tr("loop with %ecx and not zero"));
+        Instructions.insert("loopz",QObject::tr("loop with %ecx and zero"));
+        Instructions.insert("lret",QObject::tr("return from far procedure."));
+        Instructions.insert("ret",QObject::tr("return."));
+
+        //String Instructions
+        Instructions.insert("coms",QObject::tr("compare string."));
+        Instructions.insert("cpmsb",QObject::tr("compare %1 string.").arg(QObject::tr("byte")));
+        Instructions.insert("cmpsw",QObject::tr("compare %1 string.").arg(QObject::tr("word")));
+        Instructions.insert("cmpsl",QObject::tr("compare %1 string.").arg(QObject::tr("double word")));
+        Instructions.insert("cmpsq",QObject::tr("compare %1 string.").arg(QObject::tr("quad word")));
+        Instructions.insert("lods",QObject::tr("load string."));
+        Instructions.insert("lodsb",QObject::tr("load %1 string.").arg(QObject::tr("byte")));
+        Instructions.insert("lodsw",QObject::tr("load %1 string.").arg(QObject::tr("word")));
+        Instructions.insert("lodsl",QObject::tr("load %1 string.").arg(QObject::tr("double word")));
+        Instructions.insert("lodsq",QObject::tr("load %1 string.").arg(QObject::tr("quad word")));
+        Instructions.insert("movs",QObject::tr("move string."));
+        Instructions.insert("movsb",QObject::tr("move %1 string.").arg(QObject::tr("byte")));
+        Instructions.insert("movsw",QObject::tr("move %1 string.").arg(QObject::tr("word")));
+        Instructions.insert("movsl",QObject::tr("move %1 string.").arg(QObject::tr("double word")));
+        Instructions.insert("movsq",QObject::tr("move %1 string.").arg(QObject::tr("quad word")));
+        Instructions.insert("rep",QObject::tr("repeat while %ecx not zero"));
+        Instructions.insert("repnz",QObject::tr("repeat while not equal."));
+        Instructions.insert("repnz",QObject::tr("repeat while not zero."));
+        Instructions.insert("repz",QObject::tr("repeat while equal."));
+        Instructions.insert("repz",QObject::tr("repeat while zero."));
+        Instructions.insert("scas",QObject::tr("scan string."));
+        Instructions.insert("scasb",QObject::tr("scan %1 string.").arg(QObject::tr("byte")));
+        Instructions.insert("scasw",QObject::tr("scan %1 string.").arg(QObject::tr("word")));
+        Instructions.insert("scasl",QObject::tr("scan %1 string.").arg(QObject::tr("double word")));
+        Instructions.insert("scasq",QObject::tr("scan %1 string.").arg(QObject::tr("quad word")));
+        Instructions.insert("stos",QObject::tr("store string."));
+        Instructions.insert("stosb",QObject::tr("store %1 string.").arg(QObject::tr("byte")));
+        Instructions.insert("stosw",QObject::tr("store %1 string.").arg(QObject::tr("word")));
+        Instructions.insert("stosl",QObject::tr("store %1 string.").arg(QObject::tr("double word")));
+        Instructions.insert("stosq",QObject::tr("store %1 string.").arg(QObject::tr("quad word")));
+        //I/O Instructions
+        Instructions.insert("in",QObject::tr("read from a port."));
+        Instructions.insert("ins",QObject::tr("input string from a port."));
+        Instructions.insert("insb",QObject::tr("input byte string from port."));
+        Instructions.insert("insl",QObject::tr("input double word string from port."));
+        Instructions.insert("insw",QObject::tr("input word string from port."));
+        Instructions.insert("out",QObject::tr("write to a port."));
+        Instructions.insert("outs",QObject::tr("output string to port."));
+        Instructions.insert("outsb",QObject::tr("output byte string to port."));
+        Instructions.insert("outsl",QObject::tr("output double word string to port."));
+        Instructions.insert("outsw",QObject::tr("output word string to port."));
+        //Flag Control (EFLAG) Instructions
+        Instructions.insert("clc",QObject::tr("clear carry flag."));
+        Instructions.insert("cld",QObject::tr("clear direction flag."));
+        Instructions.insert("cli",QObject::tr("clear interrupt flag."));
+        Instructions.insert("cmc",QObject::tr("complement carry flag."));
+        Instructions.insert("lahf",QObject::tr("load flags into %ah register"));
+        Instructions.insert("popfw",QObject::tr("pop %eflags from stack"));
+        Instructions.insert("popf{lq}",QObject::tr("pop %eflags from stack"));
+        Instructions.insert("pushfw",QObject::tr("push %eflags onto stack"));
+        Instructions.insert("pushf{lq}",QObject::tr("push %eflags onto stack"));
+        Instructions.insert("sahf",QObject::tr("store %ah register into flags"));
+        Instructions.insert("stc",QObject::tr("set carry flag."));
+        Instructions.insert("std",QObject::tr("set direction flag."));
+        Instructions.insert("sti",QObject::tr("set interrupt flag."));
+        //Segment Register Instructions
+        Instructions.insert("lds",QObject::tr("load far pointer using %ds"));
+        Instructions.insert("les",QObject::tr("load far pointer using %es"));
+        Instructions.insert("lfs",QObject::tr("load far pointer using %fs"));
+        Instructions.insert("lgs",QObject::tr("load far pointer using %gs"));
+        Instructions.insert("lss",QObject::tr("load far pointer using %ss"));
+
+        Instructions.insert("cpuid",QObject::tr("processor identification."));
+        Instructions.insert("lea",QObject::tr("load effective address."));
+        Instructions.insert("leaw",QObject::tr("load effective address."));
+        Instructions.insert("leal",QObject::tr("load effective address."));
+        Instructions.insert("leaq",QObject::tr("load effective address."));
+        Instructions.insert("nop",QObject::tr("no operation."));
+        Instructions.insert("ud2",QObject::tr("undefined instruction."));
+        Instructions.insert("xlat",QObject::tr("table lookup translation."));
+        Instructions.insert("xlatb",QObject::tr("table lookup translation."));
+
+        //Floating-Point Instructions
+        //Data Transfer Instructions (Floating Point)
+        Instructions.insert("fbld",QObject::tr("load bcd."));
+        Instructions.insert("fbstp",QObject::tr("store bcd and pop."));
+        Instructions.insert("fcmovb",QObject::tr("floating-point conditional move if below."));
+        Instructions.insert("fcmovbe",QObject::tr("floating-point conditional move if below or equal."));
+        Instructions.insert("fcmove",QObject::tr("floating-point conditional move if equal."));
+        Instructions.insert("fcmovnb",QObject::tr("floating-point conditional move if not below."));
+        Instructions.insert("fcmovnbe",QObject::tr("floating-point conditional move if not below or equal."));
+        Instructions.insert("fcmovne",QObject::tr("floating-point conditional move if not equal."));
+        Instructions.insert("fcmovnu",QObject::tr("floating-point conditional move if unordered."));
+        Instructions.insert("fcmovu",QObject::tr("floating-point conditional move if unordered."));
+        Instructions.insert("fild",QObject::tr("load integer."));
+        Instructions.insert("fist",QObject::tr("store integer."));
+        Instructions.insert("fistp",QObject::tr("store integer and pop."));
+        Instructions.insert("fld",QObject::tr("load floating-point value."));
+        Instructions.insert("fst",QObject::tr("store floating-point value."));
+        Instructions.insert("fstp",QObject::tr("store floating-point value and pop."));
+        Instructions.insert("fxch",QObject::tr("exchange registers ."));
+        //Basic Arithmetic Instructions (Floating-Point)
+        Instructions.insert("fabs",QObject::tr("absolute value."));
+        Instructions.insert("fadd",QObject::tr("add floating-point."));
+        Instructions.insert("faddp",QObject::tr("add floating-point and pop."));
+        Instructions.insert("fchs",QObject::tr("change sign."));
+        Instructions.insert("fdiv",QObject::tr("divide floating-point."));
+        Instructions.insert("fdivp",QObject::tr("divide floating-point and pop."));
+        Instructions.insert("fdivr",QObject::tr("divide floating-point reverse."));
+        Instructions.insert("fdivrp",QObject::tr("divide floating-point reverse and pop."));
+        Instructions.insert("fiadd",QObject::tr("add integer."));
+        Instructions.insert("fidiv",QObject::tr("divide integer."));
+        Instructions.insert("fidivr",QObject::tr("divide integer reverse."));
+        Instructions.insert("fimul",QObject::tr("multiply integer."));
+        Instructions.insert("fisub",QObject::tr("subtract integer."));
+        Instructions.insert("fisubr",QObject::tr("subtract integer reverse."));
+        Instructions.insert("fmul",QObject::tr("multiply floating-point."));
+        Instructions.insert("fmulp",QObject::tr("multiply floating-point and pop."));
+        Instructions.insert("fprem",QObject::tr("partial remainder."));
+        Instructions.insert("fprem1",QObject::tr("ieee partial remainder."));
+        Instructions.insert("frndint",QObject::tr("round to integer."));
+        Instructions.insert("fscale",QObject::tr("scale by power of two."));
+        Instructions.insert("fsqrt",QObject::tr("square root."));
+        Instructions.insert("fsub",QObject::tr("subtract floating-point."));
+        Instructions.insert("fsubp",QObject::tr("subtract floating-point and pop."));
+        Instructions.insert("fsubr",QObject::tr("subtract floating-point reverse."));
+        Instructions.insert("fsubrp",QObject::tr("subtract floating-point reverse and pop."));
+        Instructions.insert("fxtract",QObject::tr("extract exponent and significand ."));
+        //Comparison Instructions (Floating-Point)
+        Instructions.insert("fcom",QObject::tr("compare floating-point."));
+        Instructions.insert("fcomi",QObject::tr("compare floating-point and set %eflags."));
+        Instructions.insert("fcomip",QObject::tr("compare floating-point, set %eflags, and pop."));
+        Instructions.insert("fcomp",QObject::tr("compare floating-point and pop."));
+        Instructions.insert("fcompp",QObject::tr("compare floating-point and pop twice."));
+        Instructions.insert("ficom",QObject::tr("compare integer."));
+        Instructions.insert("ficomp",QObject::tr("compare integer and pop."));
+        Instructions.insert("ftst",QObject::tr("test floating-point (compare with 0.0)."));
+        Instructions.insert("fucom",QObject::tr("unordered compare floating-point."));
+        Instructions.insert("fucomi",QObject::tr("unordered compare floating-point and set %eflags."));
+        Instructions.insert("fucomip",QObject::tr("unordered compare floating-point, set %eflags, and pop."));
+        Instructions.insert("fucomp",QObject::tr("unordered compare floating-point and pop."));
+        Instructions.insert("fucompp",QObject::tr("compare floating-point and pop twice."));
+        Instructions.insert("fxam",QObject::tr("examine floating-point ."));
+        Instructions.insert("transcendental",QObject::tr("instructions (floating-point)	."));
+        Instructions.insert("the",QObject::tr("transcendental instructions perform trigonometric and logarithmic operations on floating-point operands.	."));
+        Instructions.insert("table",QObject::tr("3–16 transcendental instructions (floating-point)."));
+        Instructions.insert("solaris",QObject::tr("mnemonic 	description."));
+        Instructions.insert("f2xm1",QObject::tr("computes 2x-1."));
+        Instructions.insert("fcos",QObject::tr("cosine."));
+        Instructions.insert("fpatan",QObject::tr("partial arctangent."));
+        Instructions.insert("fptan",QObject::tr("partial tangent."));
+        Instructions.insert("fsin",QObject::tr("sine."));
+        Instructions.insert("fsincos",QObject::tr("sine and cosine."));
+        Instructions.insert("fyl2x",QObject::tr("computes y * log2x."));
+        Instructions.insert("fyl2xp1",QObject::tr("computes y * log2(x+1)."));
+        //Load Constants (Floating-Point) Instructions
+        Instructions.insert("fld1",QObject::tr("load +1.0."));
+        Instructions.insert("fldl2e",QObject::tr("load log2e."));
+        Instructions.insert("fldl2t",QObject::tr("load log210."));
+        Instructions.insert("fldlg2",QObject::tr("load log102."));
+        Instructions.insert("fldln2",QObject::tr("load loge2."));
+        Instructions.insert("fldpi",QObject::tr("load π."));
+        Instructions.insert("fldz",QObject::tr("load +0.0 ."));
+        //Control Instructions (Floating-Point)
+        Instructions.insert("fclex",QObject::tr("clear floating-point exception flags after checking for error conditions."));
+        Instructions.insert("fdecstp",QObject::tr("decrement floating-point register stack pointer."));
+        Instructions.insert("ffree",QObject::tr("free floating-point register."));
+        Instructions.insert("fincstp",QObject::tr("increment floating-point register stack pointer."));
+        Instructions.insert("finit",QObject::tr("initialize floating-point unit after checking error conditions."));
+        Instructions.insert("fldcw",QObject::tr("load floating-point unit control word."));
+        Instructions.insert("fldenv",QObject::tr("load floating-point unit environment."));
+        Instructions.insert("fnclex",QObject::tr("clear floating-point exception flags without checking for error conditions."));
+        Instructions.insert("fninit",QObject::tr("initialize floating-point unit without checking error conditions."));
+        Instructions.insert("fnop",QObject::tr("floating-point no operation."));
+        Instructions.insert("fnsave",QObject::tr("save floating-point unit state without checking error conditions."));
+        Instructions.insert("fnstcw",QObject::tr("store floating-point unit control word without checking error conditions."));
+        Instructions.insert("fnstenv",QObject::tr("store floating-point unit environment without checking error conditions."));
+        Instructions.insert("fnstsw",QObject::tr("store floating-point unit status word without checking error conditions."));
+        Instructions.insert("frstor",QObject::tr("restore floating-point unit state."));
+        Instructions.insert("fsave",QObject::tr("save floating-point unit state after checking error conditions."));
+        Instructions.insert("fstcw",QObject::tr("store floating-point unit control word after checking error conditions."));
+        Instructions.insert("fstenv",QObject::tr("store floating-point unit environment after checking error conditions."));
+        Instructions.insert("fstsw",QObject::tr("store floating-point unit status word after checking error conditions."));
+        Instructions.insert("fwait",QObject::tr("wait for floating-point unit."));
+        Instructions.insert("wait",QObject::tr("wait for floating-point unit."));
+
+        //SIMD State Management Instructions
+        Instructions.insert("fxrstor",QObject::tr("restore floating-point unit and simd state."));
+        Instructions.insert("fxsave",QObject::tr("save floating-point unit and simd state."));
+
+        //MMX Instructions
+        //Data Transfer Instructions (MMX)
+        Instructions.insert("movd",QObject::tr("Move %1.").arg(QObject::tr("double word")));
+        //Conversion Instructions (MMX)
+        Instructions.insert("packssdw",QObject::tr("pack doublewords into words with signed saturation."));
+        Instructions.insert("packsswb",QObject::tr("pack words into bytes with signed saturation."));
+        Instructions.insert("packuswb",QObject::tr("pack words into bytes with unsigned saturation."));
+        Instructions.insert("punpckhbw",QObject::tr("unpack high-order bytes."));
+        Instructions.insert("punpckhdq",QObject::tr("unpack high-order doublewords."));
+        Instructions.insert("punpckhwd",QObject::tr("unpack high-order words."));
+        Instructions.insert("punpcklbw",QObject::tr("unpack low-order bytes."));
+        Instructions.insert("punpckldq",QObject::tr("unpack low-order doublewords."));
+        Instructions.insert("punpcklwd",QObject::tr("unpack low-order words."));
+        //Packed Arithmetic Instructions (MMX)
+        Instructions.insert("paddb",QObject::tr("add packed byte integers."));
+        Instructions.insert("paddd",QObject::tr("add packed doubleword integers."));
+        Instructions.insert("paddsb",QObject::tr("add packed signed byte integers with signed saturation."));
+        Instructions.insert("paddsw",QObject::tr("add packed signed word integers with signed saturation."));
+        Instructions.insert("paddusb",QObject::tr("add packed unsigned byte integers with unsigned saturation."));
+        Instructions.insert("paddusw",QObject::tr("add packed unsigned word integers with unsigned saturation."));
+        Instructions.insert("paddw",QObject::tr("add packed word integers."));
+        Instructions.insert("pmaddwd",QObject::tr("multiply and add packed word integers."));
+        Instructions.insert("pmulhw",QObject::tr("multiply packed signed word integers and store high result."));
+        Instructions.insert("pmullw",QObject::tr("multiply packed signed word integers and store low result."));
+        Instructions.insert("psubb",QObject::tr("subtract packed byte integers."));
+        Instructions.insert("psubd",QObject::tr("subtract packed doubleword integers."));
+        Instructions.insert("psubsb",QObject::tr("subtract packed signed byte integers with signed saturation."));
+        Instructions.insert("psubsw",QObject::tr("subtract packed signed word integers with signed saturation."));
+        Instructions.insert("psubusb",QObject::tr("subtract packed unsigned byte integers with unsigned saturation."));
+        Instructions.insert("psubusw",QObject::tr("subtract packed unsigned word integers with unsigned saturation."));
+        Instructions.insert("psubw",QObject::tr("subtract packed word integers."));
+        //Comparison Instructions (MMX)
+        Instructions.insert("pcmpeqb",QObject::tr("compare packed bytes for equal."));
+        Instructions.insert("pcmpeqd",QObject::tr("compare packed doublewords for equal."));
+        Instructions.insert("pcmpeqw",QObject::tr("compare packed words for equal."));
+        Instructions.insert("pcmpgtb",QObject::tr("compare packed signed byte integers for greater than."));
+        Instructions.insert("pcmpgtd",QObject::tr("compare packed signed doubleword integers for greater than."));
+        Instructions.insert("pcmpgtw",QObject::tr("compare packed signed word integers for greater than."));
+        //Logical Instructions (MMX)
+        Instructions.insert("pand",QObject::tr("bitwise logical and."));
+        Instructions.insert("pandn",QObject::tr("bitwise logical and not."));
+        Instructions.insert("por",QObject::tr("bitwise logical or."));
+        Instructions.insert("pxor",QObject::tr("bitwise logical xor."));
+        //Shift and Rotate Instructions (MMX)
+        Instructions.insert("pslld",QObject::tr("shift packed doublewords left logical."));
+        Instructions.insert("psllq",QObject::tr("shift packed quadword left logical."));
+        Instructions.insert("psllw",QObject::tr("shift packed words left logical."));
+        Instructions.insert("psrad",QObject::tr("shift packed doublewords right arithmetic."));
+        Instructions.insert("psraw",QObject::tr("shift packed words right arithmetic."));
+        Instructions.insert("psrld",QObject::tr("shift packed doublewords right logical."));
+        Instructions.insert("psrlq",QObject::tr("shift packed quadword right logical."));
+        Instructions.insert("psrlw",QObject::tr("shift packed words right logical."));
+        //State Management Instructions (MMX)
+        Instructions.insert("emms",QObject::tr("empty mmx state."));
+
+        //SSE Instructions
+        //SIMD Single-Precision Floating-Point Instructions (SSE)
+        //Data Transfer Instructions (SSE)
+        Instructions.insert("solaris",QObject::tr("mnemonic 	description."));
+        Instructions.insert("movaps",QObject::tr("move four aligned packed single-precision floating-point values between xmm registers or memory."));
+        Instructions.insert("movhlps",QObject::tr("move two packed single-precision floating-point values from the high quadword of an xmm register to the low quadword of another xmm register."));
+        Instructions.insert("movhps",QObject::tr("move two packed single-precision floating-point values to or from the high quadword of an xmm register or memory."));
+        Instructions.insert("movlhps",QObject::tr("move two packed single-precision floating-point values from the low quadword of an xmm register to the high quadword of another xmm register."));
+        Instructions.insert("movlps",QObject::tr("move two packed single-precision floating-point values to or from the low quadword of an xmm register or memory."));
+        Instructions.insert("movmskps",QObject::tr("extract sign mask from four packed single-precision floating-point values."));
+        Instructions.insert("movss",QObject::tr("move scalar single-precision floating-point value between xmm registers or memory."));
+        Instructions.insert("movups",QObject::tr("move four unaligned packed single-precision floating-point values between xmm registers or memory."));
+        //Packed Arithmetic Instructions (SSE)
+        Instructions.insert("addps",QObject::tr("add packed single-precision floating-point values."));
+        Instructions.insert("addss",QObject::tr("add scalar single-precision floating-point values."));
+        Instructions.insert("divps",QObject::tr("divide packed single-precision floating-point values."));
+        Instructions.insert("divss",QObject::tr("divide scalar single-precision floating-point values."));
+        Instructions.insert("maxps",QObject::tr("return maximum packed single-precision floating-point values."));
+        Instructions.insert("maxss",QObject::tr("return maximum scalar single-precision floating-point values."));
+        Instructions.insert("minps",QObject::tr("return minimum packed single-precision floating-point values."));
+        Instructions.insert("minss",QObject::tr("return minimum scalar single-precision floating-point values.."));
+        Instructions.insert("mulps",QObject::tr("multiply packed single-precision floating-point values."));
+        Instructions.insert("mulss",QObject::tr("multiply scalar single-precision floating-point values."));
+        Instructions.insert("rcpps",QObject::tr("compute reciprocals of packed single-precision floating-point values."));
+        Instructions.insert("rcpss",QObject::tr("compute reciprocal of scalar single-precision floating-point values."));
+        Instructions.insert("rsqrtps",QObject::tr("compute reciprocals of square roots of packed single-precision floating-point values."));
+        Instructions.insert("rsqrtss",QObject::tr("compute reciprocal of square root of scalar single-precision floating-point values."));
+        Instructions.insert("sqrtps",QObject::tr("compute square roots of packed single-precision floating-point values."));
+        Instructions.insert("sqrtss",QObject::tr("compute square root of scalar single-precision floating-point values."));
+        Instructions.insert("subps",QObject::tr("subtract packed single-precision floating-point values."));
+        Instructions.insert("subss",QObject::tr("subtract scalar single-precision floating-point values."));
+        //Comparison Instructions (SSE)
+        Instructions.insert("cmpps",QObject::tr("compare packed single-precision floating-point values."));
+        Instructions.insert("cmpss",QObject::tr("compare scalar single-precision floating-point values."));
+        Instructions.insert("comiss",QObject::tr("perform ordered comparison of scalar single-precision floating-point values and set flags in eflags register."));
+        Instructions.insert("ucomiss",QObject::tr("perform unordered comparison of scalar single-precision floating-point values and set flags in eflags register."));
+        //Logical Instructions (SSE)
+        Instructions.insert("andnps",QObject::tr("perform bitwise logical and not of packed single-precision floating-point values."));
+        Instructions.insert("andps",QObject::tr("perform bitwise logical and of packed single-precision floating-point values."));
+        Instructions.insert("orps",QObject::tr("perform bitwise logical or of packed single-precision floating-point values."));
+        Instructions.insert("xorps",QObject::tr("perform bitwise logical xor of packed single-precision floating-point values."));
+        //Shuffle and Unpack Instructions (SSE)
+        Instructions.insert("shufps",QObject::tr("shuffles values in packed single-precision floating-point operands."));
+        Instructions.insert("unpckhps",QObject::tr("unpacks and interleaves the two high-order values from two single-precision floating-point operands."));
+        Instructions.insert("unpcklps",QObject::tr("unpacks and interleaves the two low-order values from two single-precision floating-point operands."));
+        //Conversion Instructions (SSE)
+        Instructions.insert("cvtpi2ps",QObject::tr("convert packed doubleword integers to packed single-precision floating-point values."));
+        Instructions.insert("cvtps2pi",QObject::tr("convert packed single-precision floating-point values to packed doubleword integers."));
+        Instructions.insert("cvtsi2ss",QObject::tr("convert doubleword integer to scalar single-precision floating-point value."));
+        Instructions.insert("cvtss2si",QObject::tr("convert scalar single-precision floating-point value to a doubleword integer."));
+        Instructions.insert("cvttps2pi",QObject::tr("convert with truncation packed single-precision floating-point values to packed doubleword integers."));
+        Instructions.insert("cvttss2si",QObject::tr("convert with truncation scalar single-precision floating-point value to scalar doubleword integer."));
+        //MXCSR State Management Instructions (SSE)
+        Instructions.insert("ldmxcsr",QObject::tr("load %mxcsr register."));
+        Instructions.insert("stmxcsr",QObject::tr("save %mxcsr register state."));
+        //64–Bit SIMD Integer Instructions (SSE)
+        Instructions.insert("pavgb",QObject::tr("compute average of packed unsigned byte integers."));
+        Instructions.insert("pavgw",QObject::tr("compute average of packed unsigned byte integers."));
+        Instructions.insert("pextrw",QObject::tr("extract word."));
+        Instructions.insert("pinsrw",QObject::tr("insert word."));
+        Instructions.insert("pmaxsw",QObject::tr("maximum of packed signed word integers."));
+        Instructions.insert("pmaxub",QObject::tr("maximum of packed unsigned byte integers."));
+        Instructions.insert("pminsw",QObject::tr("minimum of packed signed word integers."));
+        Instructions.insert("pminub",QObject::tr("minimum of packed unsigned byte integers."));
+        Instructions.insert("pmovmskb",QObject::tr("move byte mask."));
+        Instructions.insert("pmulhuw",QObject::tr("multiply packed unsigned integers and store high result."));
+        Instructions.insert("psadbw",QObject::tr("compute sum of absolute differences."));
+        Instructions.insert("pshufw",QObject::tr("shuffle packed integer word in mmx register."));
+        //Miscellaneous Instructions (SSE)
+        Instructions.insert("maskmovq",QObject::tr("non-temporal store of selected bytes from an mmx register into memory."));
+        Instructions.insert("movntps",QObject::tr("non-temporal store of four packed single-precision floating-point values from an xmm register into memory."));
+        Instructions.insert("movntq",QObject::tr("non-temporal store of quadword from an mmx register into memory."));
+        Instructions.insert("prefetchnta",QObject::tr("prefetch data into non-temporal cache structure and into a location close to the processor."));
+        Instructions.insert("prefetcht0",QObject::tr("prefetch data into all levels of the cache hierarchy."));
+        Instructions.insert("prefetcht1",QObject::tr("prefetch data into level 2 cache and higher."));
+        Instructions.insert("prefetcht2",QObject::tr("prefetch data into level 2 cache and higher."));
+        Instructions.insert("sfence",QObject::tr("serialize store operations."));
+
+        //SSE2 Instructions
+        //SSE2 Packed and Scalar Double-Precision Floating-Point Instructions
+        //SSE2 Data Movement Instructions
+        Instructions.insert("movapd",QObject::tr("move two aligned packed double-precision floating-point values between xmm registers and memory."));
+        Instructions.insert("movhpd",QObject::tr("move high packed double-precision floating-point value to or from the high quadword of an xmm register and memory."));
+        Instructions.insert("movlpd",QObject::tr("move low packed single-precision floating-point value to or from the low quadword of an xmm register and memory."));
+        Instructions.insert("movmskpd",QObject::tr("extract sign mask from two packed double-precision floating-point values."));
+        Instructions.insert("movsd",QObject::tr("move scalar double-precision floating-point value between xmm registers and memory.."));
+        Instructions.insert("movupd",QObject::tr("move two unaligned packed double-precision floating-point values between xmm registers and memory."));
+        //SSE2 Packed Arithmetic Instructions
+        Instructions.insert("addpd",QObject::tr("add packed double-precision floating-point values."));
+        Instructions.insert("addsd",QObject::tr("add scalar double-precision floating-point values."));
+        Instructions.insert("divpd",QObject::tr("divide packed double-precision floating-point values."));
+        Instructions.insert("divsd",QObject::tr("divide scalar double-precision floating-point values."));
+        Instructions.insert("maxpd",QObject::tr("return maximum packed double-precision floating-point values."));
+        Instructions.insert("maxsd",QObject::tr("return maximum scalar double-precision floating-point value."));
+        Instructions.insert("minpd",QObject::tr("return minimum packed double-precision floating-point values."));
+        Instructions.insert("minsd",QObject::tr("return minimum scalar double-precision floating-point value."));
+        Instructions.insert("mulpd",QObject::tr("multiply packed double-precision floating-point values."));
+        Instructions.insert("mulsd",QObject::tr("multiply scalar double-precision floating-point values."));
+        Instructions.insert("sqrtpd",QObject::tr("compute packed square roots of packed double-precision floating-point values."));
+        Instructions.insert("sqrtsd",QObject::tr("compute scalar square root of scalar double-precision floating-point value."));
+        Instructions.insert("subpd",QObject::tr("subtract packed double-precision floating-point values."));
+        Instructions.insert("subsd",QObject::tr("subtract scalar double-precision floating-point values."));
+        //SSE2 Logical Instructions
+        Instructions.insert("andnpd",QObject::tr("perform bitwise logical and not of packed double-precision floating-point values."));
+        Instructions.insert("andpd",QObject::tr("perform bitwise logical and of packed double-precision floating-point values."));
+        Instructions.insert("orpd",QObject::tr("perform bitwise logical or of packed double-precision floating-point values."));
+        Instructions.insert("xorpd",QObject::tr("perform bitwise logical xor of packed double-precision floating-point values."));
+        //SSE2 Compare Instructions
+        Instructions.insert("cmppd",QObject::tr("compare packed double-precision floating-point values."));
+        Instructions.insert("cmpsd",QObject::tr("compare scalar double-precision floating-point values."));
+        Instructions.insert("comisd",QObject::tr("perform ordered comparison of scalar double-precision floating-point values and set flags in eflags register."));
+        Instructions.insert("ucomisd",QObject::tr("perform unordered comparison of scalar double-precision floating-point values and set flags in eflags register."));
+        //SSE2 Shuffle and Unpack Instructions
+        Instructions.insert("shufpd",QObject::tr("shuffle values in packed double-precision floating-point operands."));
+        Instructions.insert("unpckhpd",QObject::tr("unpack and interleave the high values from two packed double-precision floating-point operands."));
+        Instructions.insert("unpcklpd",QObject::tr("unpack and interleave the low values from two packed double-precision floating-point operands."));
+        //SSE2 Conversion Instructions
+        Instructions.insert("cvtdq2pd",QObject::tr("convert packed doubleword integers to packed double-precision floating-point values."));
+        Instructions.insert("cvtpd2dq",QObject::tr("convert packed double-precision floating-point values to packed doubleword integers."));
+        Instructions.insert("cvtpd2pi",QObject::tr("convert packed double-precision floating-point values to packed doubleword integers."));
+        Instructions.insert("cvtpd2ps",QObject::tr("convert packed double-precision floating-point values to packed single-precision floating-point values."));
+        Instructions.insert("cvtpi2pd",QObject::tr("convert packed doubleword integers to packed double-precision floating-point values."));
+        Instructions.insert("cvtps2pd",QObject::tr("convert packed single-precision floating-point values to packed double-precision floating-point values."));
+        Instructions.insert("cvtsd2si",QObject::tr("convert scalar double-precision floating-point values to a doubleword integer."));
+        Instructions.insert("cvtsd2ss",QObject::tr("convert scalar double-precision floating-point values to scalar single-precision floating-point values."));
+        Instructions.insert("cvtsi2sd",QObject::tr("convert doubleword integer to scalar double-precision floating-point value."));
+        Instructions.insert("cvtss2sd",QObject::tr("convert scalar single-precision floating-point values to scalar double-precision floating-point values."));
+        Instructions.insert("cvttpd2dq",QObject::tr("convert with truncation packed double-precision floating-point values to packed doubleword integers."));
+        Instructions.insert("cvttpd2pi",QObject::tr("convert with truncation packed double-precision floating-point values to packed doubleword integers."));
+        Instructions.insert("cvttsd2si",QObject::tr("convert with truncation scalar double-precision floating-point values to scalar doubleword integers."));
+        //SSE2 Packed Single-Precision Floating-Point Instructions
+        Instructions.insert("cvtdq2ps",QObject::tr("convert packed doubleword integers to packed single-precision floating-point values."));
+        Instructions.insert("cvtps2dq",QObject::tr("convert packed single-precision floating-point values to packed doubleword integers."));
+        Instructions.insert("cvttps2dq",QObject::tr("convert with truncation packed single-precision floating-point values to packed doubleword integers."));
+        //SSE2 128–Bit SIMD Integer Instructions
+        Instructions.insert("movdq2q",QObject::tr("move quadword integer from xmm to mmx registers."));
+        Instructions.insert("movdqa",QObject::tr("move aligned double quadword."));
+        Instructions.insert("movdqu",QObject::tr("move unaligned double quadword."));
+        Instructions.insert("movq2dq",QObject::tr("move quadword integer from mmx to xmm registers."));
+        Instructions.insert("paddq",QObject::tr("add packed quadword integers."));
+        Instructions.insert("pmuludq",QObject::tr("multiply packed unsigned doubleword integers."));
+        Instructions.insert("pshufd",QObject::tr("shuffle packed doublewords."));
+        Instructions.insert("pshufhw",QObject::tr("shuffle packed high words."));
+        Instructions.insert("pshuflw",QObject::tr("shuffle packed low words."));
+        Instructions.insert("pslldq",QObject::tr("shift double quadword left logical."));
+        Instructions.insert("psrldq",QObject::tr("shift double quadword right logical."));
+        Instructions.insert("psubq",QObject::tr("subtract packed quadword integers."));
+        Instructions.insert("punpckhqdq",QObject::tr("unpack high quadwords."));
+        Instructions.insert("punpcklqdq",QObject::tr("unpack low quadwords."));
+        //SSE2 Miscellaneous Instructions
+        Instructions.insert("clflush",QObject::tr("flushes and invalidates a memory operand and its associated cache line from all levels of the processor's cache hierarchy."));
+        Instructions.insert("lfence",QObject::tr("serializes load operations."));
+        Instructions.insert("maskmovdqu",QObject::tr("non-temporal store of selected bytes from an xmm register into memory."));
+        Instructions.insert("mfence",QObject::tr("serializes load and store operations."));
+        Instructions.insert("movntdq",QObject::tr("non-temporal store of double quadword from an xmm register into memory."));
+        Instructions.insert("movnti",QObject::tr("non-temporal store of a doubleword from a general-purpose register into memory."));
+        Instructions.insert("movntpd",QObject::tr("non-temporal store of two packed double-precision floating-point values from an xmm register into memory."));
+        Instructions.insert("pause",QObject::tr("improves the performance of spin-wait loops."));
+
+        InstructionNames=QSet<QString>(Instructions.keyBegin(),Instructions.keyEnd());
+    }
+}
+
 bool ASMSyntaxer::eol() const
 {
     return mTokenID == TokenId::Null;
@@ -618,7 +1268,7 @@ void ASMSyntaxer::resetState()
 QSet<QString> ASMSyntaxer::keywords()
 {
     if (mKeywordsCache.isEmpty()) {
-        mKeywordsCache=Instructions;
+        mKeywordsCache=InstructionNames;
         if (!isATT()) {
             mKeywordsCache.unite(Directives);
             mKeywordsCache.unite(Registers);

libs/qsynedit/qsynedit/syntaxer/asm.h

@@ -53,7 +53,8 @@ public:
     const PTokenAttribute &labelAttribute() const;
     const PTokenAttribute &registerAttribute() const;
 
-    static const QSet<QString> Instructions;
+    static QMap<QString,QString> Instructions;
+    static QSet<QString> InstructionNames;
     static const QSet<QString> Registers;
     static const QSet<QString> ATTRegisters;
     static const QSet<QString> Directives;
@@ -91,6 +92,7 @@ private:
     void SymbolProc();
     void UnknownProc();
     bool isIdentStartChar(const QChar& ch);
+    static void initData();
 
     // SynHighlighter interface
 public: